General cleanup in sal module for all and unix.

Remove useless comments and header, and de duplicate a small declaration.

Change-Id: I0d4475cbbd61ea964f8e586cf0e1f68eb91c4948
Reviewed-on: https://gerrit.libreoffice.org/6016
Reviewed-by: Arnaud Versini <arnaud.versini@libreoffice.org>
Tested-by: Arnaud Versini <arnaud.versini@libreoffice.org>

18 files changed, 10 insertions, 519 deletions

diff --git a/sal/osl/all/debugbase.cxx b/sal/osl/all/debugbase.cxx
index c70a0dc7b690..d92d92dd9b09 100644
--- a/sal/osl/all/debugbase.cxx
+++ b/sal/osl/all/debugbase.cxx
@@ -66,7 +66,7 @@ inline bool isSubStr( char const* pStr, rtl::OString const& subStr )
     return rtl_str_indexOfStr( pStr, subStr.getStr() ) >= 0;
 }
 
-struct DebugBaseMutex : ::rtl::Static<osl::Mutex, DebugBaseMutex> {};
+struct DebugBaseMutex : rtl::Static<osl::Mutex, DebugBaseMutex> {};
 
 } // anon namespace
 
diff --git a/sal/osl/all/loadmodulerelative.cxx b/sal/osl/all/loadmodulerelative.cxx
index 98cf1374f5c6..2e77690ebf13 100644
--- a/sal/osl/all/loadmodulerelative.cxx
+++ b/sal/osl/all/loadmodulerelative.cxx
@@ -25,7 +25,6 @@
 #include "sal/log.hxx"
 #include "osl/module.h"
 #include "osl/module.hxx"
-#include "osl/thread.h"
 #include "rtl/malformeduriexception.hxx"
 #include "rtl/uri.hxx"
 #include "rtl/ustring.h"
@@ -40,22 +39,22 @@ oslModule SAL_CALL osl_loadModuleRelative(
     oslGenericFunction const baseModule, rtl_uString * const relativePath,
     sal_Int32 const mode)
 {
-    ::rtl::OUString base;
-    if (!::osl::Module::getUrlFromAddress(baseModule, base)) {
+    rtl::OUString base;
+    if (!osl::Module::getUrlFromAddress(baseModule, base)) {
         SAL_INFO("sal.osl","osl::Module::getUrlFromAddress failed");
         return NULL;
     }
-    ::rtl::OUString abs;
+    rtl::OUString abs;
     try {
-        abs = ::rtl::Uri::convertRelToAbs(base, relativePath);
-    } catch (const ::rtl::MalformedUriException & e) {
+        abs = rtl::Uri::convertRelToAbs(base, relativePath);
+    } catch (const rtl::MalformedUriException & e) {
         (void) e; // avoid warnings
         SAL_INFO("sal.osl",
             "rtl::MalformedUriException <" << e.getMessage() << ">");
             //TODO: let some OSL_TRACE variant take care of text conversion?
         return NULL;
     }
-    return ::osl_loadModule(abs.pData, mode);
+    return osl_loadModule(abs.pData, mode);
 }
 
 #endif // !DISABLE_DYNLOADING
diff --git a/sal/osl/all/utility.cxx b/sal/osl/all/utility.cxx
index 4c0aff71a6dd..adafdbbdc4f4 100644
--- a/sal/osl/all/utility.cxx
+++ b/sal/osl/all/utility.cxx
@@ -17,9 +17,7 @@
  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  */
 
-#include "rtl/ustring.hxx"
 #include "osl/time.h"
-#include <stdio.h>
 
 
 /*
diff --git a/sal/osl/unx/backtrace.h b/sal/osl/unx/backtrace.h
index cf5698f9309d..04e39538323c 100644
--- a/sal/osl/unx/backtrace.h
+++ b/sal/osl/unx/backtrace.h
@@ -19,7 +19,7 @@
 
 
 #if defined (SOLARIS) || defined (FREEBSD) || defined (NETBSD) || \
-    defined (OPENBSD) || defined (DRAGONFLY)
+    defined (OPENBSD) || defined (DRAGONFLY) || defined (MACOSX)
 
 #ifdef __cplusplus
 extern "C" {
@@ -53,22 +53,4 @@ struct frame {
 #include <execinfo.h>
 #endif
 
-#if defined (MACOSX)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* backtrace function with same behaviour as defined in GNU libc */
-
-int backtrace( void **buffer, int max_frames );
-
-void backtrace_symbols_fd( void **buffer, int size, int fd );
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* defined MACOSX */
-
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sal/osl/unx/conditn.cxx b/sal/osl/unx/conditn.cxx
index 90d70e1e5b5c..1daea54b68e2 100644
--- a/sal/osl/unx/conditn.cxx
+++ b/sal/osl/unx/conditn.cxx
@@ -37,9 +37,6 @@ typedef struct _oslConditionImpl
 } oslConditionImpl;
 
 
-/*****************************************************************************/
-/* osl_createCondition */
-/*****************************************************************************/
 oslCondition SAL_CALL osl_createCondition()
 {
       oslConditionImpl* pCond;
@@ -89,9 +86,6 @@ oslCondition SAL_CALL osl_createCondition()
     return (oslCondition)pCond;
 }
 
-/*****************************************************************************/
-/* osl_destroyCondition */
-/*****************************************************************************/
 void SAL_CALL osl_destroyCondition(oslCondition Condition)
 {
     oslConditionImpl* pCond;
@@ -118,9 +112,6 @@ void SAL_CALL osl_destroyCondition(oslCondition Condition)
     return;
 }
 
-/*****************************************************************************/
-/* osl_setCondition */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_setCondition(oslCondition Condition)
 {
    oslConditionImpl* pCond;
@@ -171,9 +162,6 @@ sal_Bool SAL_CALL osl_setCondition(oslCondition Condition)
 
 }
 
-/*****************************************************************************/
-/* osl_resetCondition */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_resetCondition(oslCondition Condition)
 {
     oslConditionImpl* pCond;
@@ -212,9 +200,6 @@ sal_Bool SAL_CALL osl_resetCondition(oslCondition Condition)
     return sal_True;
 }
 
-/*****************************************************************************/
-/* osl_waitCondition */
-/*****************************************************************************/
 oslConditionResult SAL_CALL osl_waitCondition(oslCondition Condition, const TimeValue* pTimeout)
 {
     oslConditionImpl* pCond;
@@ -315,9 +300,6 @@ oslConditionResult SAL_CALL osl_waitCondition(oslCondition Condition, const Time
     return Result;
 }
 
-/*****************************************************************************/
-/* osl_checkCondition */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_checkCondition(oslCondition Condition)
 {
     sal_Bool State;
diff --git a/sal/osl/unx/diagnose.cxx b/sal/osl/unx/diagnose.cxx
index 99cb9e94e639..871aa0a68006 100644
--- a/sal/osl/unx/diagnose.cxx
+++ b/sal/osl/unx/diagnose.cxx
@@ -60,9 +60,7 @@ static void osl_diagnose_backtrace_Impl (
 ((f != 0) ? (*(f))((s)) : (void)fprintf(stderr, "%s", (s)))
 
 #if defined (LINUX) || defined (SOLARIS)
-/************************************************************************/
-/* osl_diagnose_frame_Impl */
-/************************************************************************/
+
 static void osl_diagnose_frame_Impl (
     oslDebugMessageFunc f,
     int                 depth,
@@ -102,9 +100,6 @@ static void osl_diagnose_frame_Impl (
 }
 #endif
 
-/************************************************************************/
-/* osl_diagnose_backtrace_Impl */
-/************************************************************************/
 #if defined(LINUX)
 
 #include <execinfo.h>
@@ -126,7 +121,6 @@ static void osl_diagnose_backtrace_Impl (oslDebugMessageFunc f)
 
 #elif defined(SOLARIS)
 
-#include <pthread.h>
 #include <setjmp.h>
 #include <sys/frame.h>
 
@@ -190,10 +184,6 @@ static void osl_diagnose_backtrace_Impl (oslDebugMessageFunc f)
 
 #endif /* (LINUX || SOLARIS) */
 
-/************************************************************************/
-/* osl_assertFailedLine */
-/************************************************************************/
-
 namespace {
 
 // getenv is not thread safe, so minimize use of result:
@@ -255,17 +245,11 @@ sal_Bool SAL_CALL osl_assertFailedLine (
     return doAbort;
 }
 
-/************************************************************************/
-/* osl_breakDebug */
-/************************************************************************/
 void SAL_CALL osl_breakDebug()
 {
     abort();
 }
 
-/************************************************************************/
-/* osl_reportError */
-/************************************************************************/
 sal_Int32 SAL_CALL osl_reportError (
     sal_uInt32      nType,
     const sal_Char* pszMessage)
@@ -275,9 +259,6 @@ sal_Int32 SAL_CALL osl_reportError (
     return 0;
 }
 
-/************************************************************************/
-/* osl_setDebugMessageFunc */
-/************************************************************************/
 oslDebugMessageFunc SAL_CALL osl_setDebugMessageFunc (
     oslDebugMessageFunc pNewFunc)
 {
@@ -286,9 +267,6 @@ oslDebugMessageFunc SAL_CALL osl_setDebugMessageFunc (
     return pOldFunc;
 }
 
-/************************************************************************/
-/* osl_setDetailedDebugMessageFunc */
-/************************************************************************/
 pfunc_osl_printDetailedDebugMessage SAL_CALL osl_setDetailedDebugMessageFunc (
     pfunc_osl_printDetailedDebugMessage pNewFunc)
 {
diff --git a/sal/osl/unx/file.cxx b/sal/osl/unx/file.cxx
index 571a79c82998..801bca5eacf5 100644
--- a/sal/osl/unx/file.cxx
+++ b/sal/osl/unx/file.cxx
@@ -183,12 +183,6 @@ struct FileHandle_Impl
     };
 };
 
-/*******************************************************************
- *
- * FileHandle_Impl implementation
- *
- ******************************************************************/
-
 FileHandle_Impl::Allocator &
 FileHandle_Impl::Allocator::get()
 {
@@ -747,9 +741,6 @@ oslFileHandle osl::detail::createFileHandleFromFD( int fd )
     return (oslFileHandle)(pImpl);
 }
 
-/*******************************************************************
- * osl_file_adjustLockFlags
- ******************************************************************/
 static int osl_file_adjustLockFlags (const char * path, int flags)
 {
 #ifdef MACOSX
@@ -780,9 +771,6 @@ static int osl_file_adjustLockFlags (const char * path, int flags)
     return flags;
 }
 
-/****************************************************************************
- *  osl_file_queryLocking
- ***************************************************************************/
 static bool osl_file_queryLocking (sal_uInt32 uFlags)
 {
 #if !defined HAVE_O_EXLOCK
@@ -832,9 +820,6 @@ SAL_CALL osl_openMemoryAsFile( void *address, size_t size, oslFileHandle *pHandl
 
 #endif
 
-/****************************************************************************
- *  osl_openFile
- ***************************************************************************/
 #ifdef HAVE_O_EXLOCK
 #define OPEN_WRITE_FLAGS ( O_RDWR | O_EXLOCK | O_NONBLOCK )
 #define OPEN_CREATE_FLAGS ( O_CREAT | O_RDWR | O_EXLOCK | O_NONBLOCK )
@@ -1042,9 +1027,6 @@ SAL_CALL osl_openFile( rtl_uString* ustrFileURL, oslFileHandle* pHandle, sal_uIn
     return osl_openFilePath (buffer, pHandle, uFlags);
 }
 
-/****************************************************************************/
-/*  osl_closeFile */
-/****************************************************************************/
 oslFileError
 SAL_CALL osl_closeFile( oslFileHandle Handle )
 {
@@ -1084,9 +1066,6 @@ SAL_CALL osl_closeFile( oslFileHandle Handle )
     return (result);
 }
 
-/************************************************
- * osl_syncFile
- ***********************************************/
 oslFileError
 SAL_CALL osl_syncFile(oslFileHandle Handle)
 {
@@ -1110,9 +1089,6 @@ SAL_CALL osl_syncFile(oslFileHandle Handle)
     return osl_File_E_None;
 }
 
-/************************************************
- * osl_fileGetOSHandle
- ***********************************************/
 oslFileError
 SAL_CALL osl_getFileOSHandle(
     oslFileHandle Handle,
@@ -1128,9 +1104,6 @@ SAL_CALL osl_getFileOSHandle(
     return osl_File_E_None;
 }
 
-/*******************************************
-    osl_mapFile
-********************************************/
 oslFileError
 SAL_CALL osl_mapFile (
     oslFileHandle Handle,
@@ -1244,9 +1217,6 @@ unmapFile (void* pAddr, sal_uInt64 uLength)
 // folder osl_mapFile just returns a pointer to the file inside the
 // already mmapped .apk archive.
 
-/*******************************************
-    osl_unmapFile
-********************************************/
 oslFileError
 SAL_CALL osl_unmapFile (void* pAddr, sal_uInt64 uLength)
 {
@@ -1255,9 +1225,6 @@ SAL_CALL osl_unmapFile (void* pAddr, sal_uInt64 uLength)
 
 #endif
 
-/*******************************************
-    osl_unmapMappedFile
-********************************************/
 oslFileError
 SAL_CALL osl_unmapMappedFile (oslFileHandle Handle, void* pAddr, sal_uInt64 uLength)
 {
@@ -1274,9 +1241,6 @@ SAL_CALL osl_unmapMappedFile (oslFileHandle Handle, void* pAddr, sal_uInt64 uLen
     return osl_File_E_None;
 }
 
-/*******************************************
-    osl_readLine
-********************************************/
 oslFileError
 SAL_CALL osl_readLine (
     oslFileHandle   Handle,
@@ -1297,9 +1261,6 @@ SAL_CALL osl_readLine (
     return (result);
 }
 
-/*******************************************
-    osl_readFile
-********************************************/
 oslFileError
 SAL_CALL osl_readFile (
     oslFileHandle Handle,
@@ -1326,9 +1287,6 @@ SAL_CALL osl_readFile (
     return (result);
 }
 
-/*******************************************
-    osl_writeFile
-********************************************/
 oslFileError
 SAL_CALL osl_writeFile (
     oslFileHandle Handle,
@@ -1357,9 +1315,6 @@ SAL_CALL osl_writeFile (
     return (result);
 }
 
-/*******************************************
-    osl_readFileAt
-********************************************/
 oslFileError
 SAL_CALL osl_readFileAt (
     oslFileHandle Handle,
@@ -1390,9 +1345,6 @@ SAL_CALL osl_readFileAt (
     return pImpl->readFileAt (nOffset, pBuffer, nBytesRequested, pBytesRead);
 }
 
-/*******************************************
-    osl_writeFileAt
-********************************************/
 oslFileError
 SAL_CALL osl_writeFileAt (
     oslFileHandle Handle,
@@ -1425,9 +1377,6 @@ SAL_CALL osl_writeFileAt (
     return pImpl->writeFileAt (nOffset, pBuffer, nBytesToWrite, pBytesWritten);
 }
 
-/****************************************************************************/
-/*  osl_isEndOfFile */
-/****************************************************************************/
 oslFileError
 SAL_CALL osl_isEndOfFile( oslFileHandle Handle, sal_Bool *pIsEOF )
 {
@@ -1441,9 +1390,6 @@ SAL_CALL osl_isEndOfFile( oslFileHandle Handle, sal_Bool *pIsEOF )
     return osl_File_E_None;
 }
 
-/************************************************
- * osl_getFilePos
- ***********************************************/
 oslFileError
 SAL_CALL osl_getFilePos( oslFileHandle Handle, sal_uInt64* pPos )
 {
@@ -1457,9 +1403,6 @@ SAL_CALL osl_getFilePos( oslFileHandle Handle, sal_uInt64* pPos )
     return osl_File_E_None;
 }
 
-/*******************************************
-    osl_setFilePos
-********************************************/
 oslFileError
 SAL_CALL osl_setFilePos (oslFileHandle Handle, sal_uInt32 uHow, sal_Int64 uOffset)
 {
@@ -1504,9 +1447,6 @@ SAL_CALL osl_setFilePos (oslFileHandle Handle, sal_uInt32 uHow, sal_Int64 uOffse
     return pImpl->setPos (nPos + nOffset);
 }
 
-/****************************************************************************
- *  osl_getFileSize
- ****************************************************************************/
 oslFileError
 SAL_CALL osl_getFileSize( oslFileHandle Handle, sal_uInt64* pSize )
 {
@@ -1520,9 +1460,6 @@ SAL_CALL osl_getFileSize( oslFileHandle Handle, sal_uInt64* pSize )
     return osl_File_E_None;
 }
 
-/************************************************
- * osl_setFileSize
- ***********************************************/
 oslFileError
 SAL_CALL osl_setFileSize( oslFileHandle Handle, sal_uInt64 uSize )
 {
diff --git a/sal/osl/unx/file_error_transl.cxx b/sal/osl/unx/file_error_transl.cxx
index 7e7bb9b2f435..59700b995b27 100644
--- a/sal/osl/unx/file_error_transl.cxx
+++ b/sal/osl/unx/file_error_transl.cxx
@@ -21,10 +21,6 @@
 #include "file_error_transl.h"
 #include <osl/diagnose.h>
 
-/********************************************
- * oslTranslateFileError
- *******************************************/
-
 oslFileError oslTranslateFileError(sal_Bool bIsError, int Errno)
 {
     oslFileError osl_error = osl_File_E_invalidError;
diff --git a/sal/osl/unx/file_url.cxx b/sal/osl/unx/file_url.cxx
index 5a1dd2b4d0c2..f3e0e9c58576 100644
--- a/sal/osl/unx/file_url.cxx
+++ b/sal/osl/unx/file_url.cxx
@@ -363,10 +363,6 @@ namespace
         return (pStr + rtl_ustr_getLength(pStr));
     }
 
-    /*********************************************
-
-     ********************************************/
-
     sal_Unicode* ustrchrcat(const sal_Unicode chr, sal_Unicode* d)
     {
         sal_Unicode* p = ustrtoend(d);
@@ -375,10 +371,6 @@ namespace
         return d;
     }
 
-    /******************************************************
-     *
-     ******************************************************/
-
     bool _islastchr(sal_Unicode* pStr, sal_Unicode Chr)
     {
            sal_Unicode* p = ustrtoend(pStr);
@@ -424,10 +416,6 @@ namespace
         return aPath;
     }
 
-    /******************************************************
-     *
-     ******************************************************/
-
     oslFileError _osl_resolvepath(
         /*inout*/ sal_Unicode* path,
         /*inout*/ bool* failed)
@@ -677,10 +665,6 @@ namespace
         return bfound;
     }
 
-    /*********************************************
-
-     ********************************************/
-
     bool find_in_searchPath(const rtl::OUString& file_path, rtl_uString* search_path, rtl::OUString& result)
     {
         return (search_path && osl::searchPath(file_path, rtl::OUString(search_path), result));
diff --git a/sal/osl/unx/interlck.c b/sal/osl/unx/interlck.c
index 24d5b708a054..cd8b5d2125db 100644
--- a/sal/osl/unx/interlck.c
+++ b/sal/osl/unx/interlck.c
@@ -32,9 +32,6 @@
 
 extern int osl_isSingleCPU;
 
-/*****************************************************************************/
-/* osl_incrementInterlockedCount */
-/*****************************************************************************/
 oslInterlockedCount SAL_CALL osl_incrementInterlockedCount(oslInterlockedCount* pCount)
 {
     // Fast case for old, slow, single CPU Intel machines for whom
@@ -110,9 +107,6 @@ oslInterlockedCount SAL_CALL osl_decrementInterlockedCount(oslInterlockedCount*
 
 static pthread_mutex_t InterLock = PTHREAD_MUTEX_INITIALIZER;
 
-/*****************************************************************************/
-/* osl_incrementInterlockedCount */
-/*****************************************************************************/
 oslInterlockedCount SAL_CALL osl_incrementInterlockedCount(oslInterlockedCount* pCount)
 {
     oslInterlockedCount Count;
@@ -124,9 +118,6 @@ oslInterlockedCount SAL_CALL osl_incrementInterlockedCount(oslInterlockedCount*
     return (Count);
 }
 
-/*****************************************************************************/
-/* osl_decrementInterlockedCount */
-/*****************************************************************************/
 oslInterlockedCount SAL_CALL osl_decrementInterlockedCount(oslInterlockedCount* pCount)
 {
     oslInterlockedCount Count;
diff --git a/sal/osl/unx/mutex.c b/sal/osl/unx/mutex.c
index b2afa29c1116..a2a6df7abcc0 100644
--- a/sal/osl/unx/mutex.c
+++ b/sal/osl/unx/mutex.c
@@ -72,9 +72,6 @@ oslMutex SAL_CALL osl_createMutex()
     return pMutex;
 }
 
-/*****************************************************************************/
-/* osl_destroyMutex */
-/*****************************************************************************/
 void SAL_CALL osl_destroyMutex(oslMutexImpl *pMutex)
 {
     OSL_ASSERT(pMutex);
@@ -96,9 +93,6 @@ void SAL_CALL osl_destroyMutex(oslMutexImpl *pMutex)
     return;
 }
 
-/*****************************************************************************/
-/* osl_acquireMutex */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_acquireMutex(oslMutexImpl *pMutex)
 {
     OSL_ASSERT(pMutex);
@@ -121,9 +115,6 @@ sal_Bool SAL_CALL osl_acquireMutex(oslMutexImpl *pMutex)
     return sal_False;
 }
 
-/*****************************************************************************/
-/* osl_tryToAcquireMutex */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_tryToAcquireMutex(oslMutexImpl *pMutex)
 {
     OSL_ASSERT(pMutex);
@@ -142,9 +133,6 @@ sal_Bool SAL_CALL osl_tryToAcquireMutex(oslMutexImpl *pMutex)
     return sal_False;
 }
 
-/*****************************************************************************/
-/* osl_releaseMutex */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_releaseMutex(oslMutexImpl *pMutex)
 {
     OSL_ASSERT(pMutex);
@@ -167,9 +155,6 @@ sal_Bool SAL_CALL osl_releaseMutex(oslMutexImpl *pMutex)
     return sal_False;
 }
 
-/*****************************************************************************/
-/* osl_getGlobalMutex */
-/*****************************************************************************/
 
 static oslMutexImpl globalMutexImpl;
 
diff --git a/sal/osl/unx/pipe.c b/sal/osl/unx/pipe.c
index f0f91da98edc..b3d108574dac 100644
--- a/sal/osl/unx/pipe.c
+++ b/sal/osl/unx/pipe.c
@@ -39,10 +39,6 @@ sal_Bool SAL_CALL osl_psz_getUserIdent(oslSecurity Security, sal_Char *pszIdent,
 oslPipe SAL_CALL osl_psz_createPipe(const sal_Char *pszPipeName, oslPipeOptions Options, oslSecurity Security);
 
 
-/*****************************************************************************/
-/* enum oslPipeError */
-/*****************************************************************************/
-
 static struct
 {
     int            errcode;
@@ -97,10 +93,6 @@ static oslPipeError osl_PipeErrorFromNative(int nativeType)
 #define ERROR_FROM_NATIVE(y)    osl_PipeErrorFromNative(y)
 
 
-/*****************************************************************************/
-/* osl_create/destroy-PipeImpl */
-/*****************************************************************************/
-
 oslPipe __osl_createPipeImpl()
 {
     oslPipe pPipeImpl;
@@ -122,9 +114,6 @@ void __osl_destroyPipeImpl(oslPipe pImpl)
 }
 
 
-/*****************************************************************************/
-/* osl_createPipe  */
-/*****************************************************************************/
 oslPipe SAL_CALL osl_createPipe(rtl_uString *ustrPipeName, oslPipeOptions Options, oslSecurity Security)
 {
     oslPipe pPipe=0;
@@ -434,9 +423,6 @@ void SAL_CALL osl_closePipe( oslPipe pPipe )
 }
 
 
-/*****************************************************************************/
-/* osl_acceptPipe  */
-/*****************************************************************************/
 oslPipe SAL_CALL osl_acceptPipe(oslPipe pPipe)
 {
     int     s, flags;
@@ -502,9 +488,6 @@ oslPipe SAL_CALL osl_acceptPipe(oslPipe pPipe)
     return pAcceptedPipe;
 }
 
-/*****************************************************************************/
-/* osl_receivePipe  */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_receivePipe(oslPipe pPipe,
                         void* pBuffer,
                         sal_Int32 BytesToRead)
@@ -532,10 +515,6 @@ sal_Int32 SAL_CALL osl_receivePipe(oslPipe pPipe,
       return nRet;
 }
 
-
-/*****************************************************************************/
-/* osl_sendPipe  */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_sendPipe(oslPipe pPipe,
                        const void* pBuffer,
                        sal_Int32 BytesToSend)
@@ -564,10 +543,6 @@ sal_Int32 SAL_CALL osl_sendPipe(oslPipe pPipe,
      return nRet;
 }
 
-
-/*****************************************************************************/
-/* osl_getLastPipeError  */
-/*****************************************************************************/
 oslPipeError SAL_CALL osl_getLastPipeError(oslPipe pPipe)
 {
     (void) pPipe; /* unused */
diff --git a/sal/osl/unx/signal.c b/sal/osl/unx/signal.c
index 2c3f2b2f7453..e3d1b1c1426a 100644
--- a/sal/osl/unx/signal.c
+++ b/sal/osl/unx/signal.c
@@ -336,10 +336,6 @@ static sal_Bool DeInitSignal()
 
 #if defined (SAL_ENABLE_CRASH_REPORT) && defined(INCLUDE_BACKTRACE)
 
-/*****************************************************************************/
-/* Generate MD5 checksum    */
-/*****************************************************************************/
-
 static sal_uInt32 calc_md5_checksum( const char *filename, sal_uInt8 *pChecksum, sal_uInt32 nChecksumLen )
 {
     sal_uInt32  nBytesProcessed = 0;
@@ -937,9 +933,6 @@ static void DUMPCURRENTALLOCS()
 }
 #endif
 
-/*****************************************************************************/
-/* SignalHandlerFunction    */
-/*****************************************************************************/
 void SignalHandlerFunction(int Signal)
 {
     oslSignalInfo    Info;
@@ -1020,9 +1013,6 @@ void SignalHandlerFunction(int Signal)
     }
 }
 
-/*****************************************************************************/
-/* osl_addSignalHandler */
-/*****************************************************************************/
 oslSignalHandler SAL_CALL osl_addSignalHandler(oslSignalHandlerFunction Handler, void* pData)
 {
     oslSignalHandlerImpl* pHandler;
@@ -1056,9 +1046,6 @@ oslSignalHandler SAL_CALL osl_addSignalHandler(oslSignalHandlerFunction Handler,
     return (NULL);
 }
 
-/*****************************************************************************/
-/* osl_removeSignalHandler */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_removeSignalHandler(oslSignalHandler Handler)
 {
     oslSignalHandlerImpl *pHandler, *pPrevious = NULL;
@@ -1100,9 +1087,6 @@ sal_Bool SAL_CALL osl_removeSignalHandler(oslSignalHandler Handler)
     return (sal_False);
 }
 
-/*****************************************************************************/
-/* osl_raiseSignal */
-/*****************************************************************************/
 oslSignalAction SAL_CALL osl_raiseSignal(sal_Int32 UserSignal, void* UserData)
 {
     oslSignalInfo   Info;
@@ -1124,9 +1108,6 @@ oslSignalAction SAL_CALL osl_raiseSignal(sal_Int32 UserSignal, void* UserData)
     return (Action);
 }
 
-/*****************************************************************************/
-/* osl_setErrorReporting */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_setErrorReporting( sal_Bool bEnable )
 {
     sal_Bool bOld = bErrorReportingEnabled;
diff --git a/sal/osl/unx/socket.c b/sal/osl/unx/socket.c
index 1d51f3805d59..1743dc086813 100644
--- a/sal/osl/unx/socket.c
+++ b/sal/osl/unx/socket.c
@@ -440,10 +440,6 @@ oslSocketResult SAL_CALL osl_psz_getDottedInetAddrOfSocketAddr (
 void SAL_CALL osl_psz_getLastSocketErrorDescription (
     oslSocket Socket, sal_Char* pBuffer, sal_uInt32 BufferSize);
 
-/*****************************************************************************/
-/* osl_create/destroy-SocketImpl */
-/*****************************************************************************/
-
 #if OSL_DEBUG_LEVEL > 1
 static sal_uInt32 g_nSocketImpl = 0;
 static sal_uInt32 g_nSocketAddr = 0;
@@ -531,9 +527,6 @@ static void __osl_destroySocketAddr( oslSocketAddr addr )
     rtl_freeMemory( addr );
 }
 
-/*****************************************************************************/
-/* osl_createEmptySocketAddr */
-/*****************************************************************************/
 oslSocketAddr SAL_CALL osl_createEmptySocketAddr(oslAddrFamily Family)
 {
     oslSocketAddr pAddr = 0;
@@ -551,9 +544,6 @@ oslSocketAddr SAL_CALL osl_createEmptySocketAddr(oslAddrFamily Family)
     return pAddr;
 }
 
-/*****************************************************************************/
-/* osl_copySocketAddr */
-/*****************************************************************************/
 oslSocketAddr SAL_CALL osl_copySocketAddr(oslSocketAddr Addr)
 {
     oslSocketAddr pCopy = 0;
@@ -567,9 +557,6 @@ oslSocketAddr SAL_CALL osl_copySocketAddr(oslSocketAddr Addr)
     return pCopy;
 }
 
-/*****************************************************************************/
-/* osl_isEqualSocketAddr */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_isEqualSocketAddr (
     oslSocketAddr Addr1,
     oslSocketAddr Addr2)
@@ -612,9 +599,6 @@ sal_Bool SAL_CALL osl_isEqualSocketAddr (
     return (sal_False);
 }
 
-/*****************************************************************************/
-/* osl_createInetBroadcastAddr */
-/*****************************************************************************/
 oslSocketAddr SAL_CALL osl_createInetBroadcastAddr (
     rtl_uString *strDottedAddr,
     sal_Int32    Port)
@@ -666,9 +650,6 @@ oslSocketAddr SAL_CALL osl_createInetBroadcastAddr (
     return pAddr;
 }
 
-/*****************************************************************************/
-/* osl_createInetSocketAddr */
-/*****************************************************************************/
 oslSocketAddr SAL_CALL osl_createInetSocketAddr (
     rtl_uString *ustrDottedAddr,
     sal_Int32    Port)
@@ -712,9 +693,6 @@ oslSocketAddr SAL_CALL osl_psz_createInetSocketAddr (
     return pAddr;
 }
 
-/*****************************************************************************/
-/* osl_setAddrOfSocketAddr */
-/*****************************************************************************/
 oslSocketResult SAL_CALL osl_setAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence *pByteSeq )
 {
     oslSocketResult res = osl_Socket_Error;
@@ -736,9 +714,6 @@ oslSocketResult SAL_CALL osl_setAddrOfSocketAddr( oslSocketAddr pAddr, sal_Seque
     return res;
 }
 
-/*****************************************************************************/
-/* osl_getAddrOfSocketAddr */
-/*****************************************************************************/
 oslSocketResult SAL_CALL osl_getAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence **ppByteSeq )
 {
     oslSocketResult res = osl_Socket_Error;
@@ -756,10 +731,6 @@ oslSocketResult SAL_CALL osl_getAddrOfSocketAddr( oslSocketAddr pAddr, sal_Seque
 }
 
 
-/*****************************************************************************/
-/* _osl_getFullQualifiedDomainName */
-/*****************************************************************************/
-
 /** try to figure out a full-qualified hostname, by adding the current domain
     as given by the domainname program to the given hostname.
     This function MUST NOT call gethostbyname since pHostName already points
@@ -805,9 +776,7 @@ static sal_Char* _osl_getFullQualifiedDomainName (const sal_Char *pHostName)
     }
     return pFullQualifiedName;
 }
-/*****************************************************************************/
-/* _osl_isFullQualifiedDomainName */
-/*****************************************************************************/
+
 static sal_Bool _osl_isFullQualifiedDomainName (const sal_Char *pHostName)
 {
     /* a FQDN (aka 'hostname.domain.top_level_domain' )
@@ -817,9 +786,6 @@ static sal_Bool _osl_isFullQualifiedDomainName (const sal_Char *pHostName)
     return (sal_Bool)( strchr( pHostName, (int)'.' ) != NULL );
 }
 
-/*****************************************************************************/
-/* oslHostAddr */
-/*****************************************************************************/
 struct oslHostAddrImpl
 {
     sal_Char        *pHostName;
@@ -898,9 +864,6 @@ static oslHostAddr _osl_hostentToHostAddr (const struct hostent *he)
     return pAddr;
 }
 
-/*****************************************************************************/
-/* osl_createHostAddr */
-/*****************************************************************************/
 oslHostAddr SAL_CALL osl_createHostAddr (
     rtl_uString        *ustrHostname,
     const oslSocketAddr Addr)
@@ -961,9 +924,6 @@ oslHostAddr SAL_CALL osl_psz_createHostAddr (
     return pHostAddr;
 }
 
-/*****************************************************************************/
-/* osl_createHostAddrByName */
-/*****************************************************************************/
 oslHostAddr SAL_CALL osl_createHostAddrByName(rtl_uString *ustrHostname)
 {
     oslHostAddr HostAddr;
@@ -1005,9 +965,6 @@ oslHostAddr SAL_CALL osl_psz_createHostAddrByName (const sal_Char *pszHostname)
     return _osl_hostentToHostAddr (pHe);
 }
 
-/*****************************************************************************/
-/* osl_createHostAddrByAddr */
-/*****************************************************************************/
 oslHostAddr SAL_CALL osl_createHostAddrByAddr (const oslSocketAddr pAddr)
 {
     OSL_ASSERT(pAddr);
@@ -1032,9 +989,6 @@ oslHostAddr SAL_CALL osl_createHostAddrByAddr (const oslSocketAddr pAddr)
     return ((oslHostAddr)NULL);
 }
 
-/*****************************************************************************/
-/* osl_copyHostAddr */
-/*****************************************************************************/
 oslHostAddr SAL_CALL osl_copyHostAddr (const oslHostAddr pAddr)
 {
     OSL_ASSERT(pAddr);
@@ -1045,9 +999,6 @@ oslHostAddr SAL_CALL osl_copyHostAddr (const oslHostAddr pAddr)
         return ((oslHostAddr)NULL);
 }
 
-/*****************************************************************************/
-/* osl_getHostnameOfHostAddr */
-/*****************************************************************************/
 void SAL_CALL osl_getHostnameOfHostAddr (
     const oslHostAddr   Addr,
     rtl_uString       **ustrHostname)
@@ -1069,9 +1020,6 @@ const sal_Char* SAL_CALL osl_psz_getHostnameOfHostAddr (const oslHostAddr pAddr)
         return NULL;
 }
 
-/*****************************************************************************/
-/* osl_getSocketAddrOfHostAddr */
-/*****************************************************************************/
 oslSocketAddr SAL_CALL osl_getSocketAddrOfHostAddr (const oslHostAddr pAddr)
 {
     OSL_ASSERT(pAddr);
@@ -1082,9 +1030,6 @@ oslSocketAddr SAL_CALL osl_getSocketAddrOfHostAddr (const oslHostAddr pAddr)
         return NULL;
 }
 
-/*****************************************************************************/
-/* osl_destroyHostAddr */
-/*****************************************************************************/
 void SAL_CALL osl_destroyHostAddr (oslHostAddr pAddr)
 {
     if (pAddr)
@@ -1097,9 +1042,6 @@ void SAL_CALL osl_destroyHostAddr (oslHostAddr pAddr)
     }
 }
 
-/*****************************************************************************/
-/* osl_getLocalHostname */
-/*****************************************************************************/
 oslSocketResult SAL_CALL osl_getLocalHostname(rtl_uString **ustrLocalHostname)
 {
     oslSocketResult Result;
@@ -1167,9 +1109,6 @@ oslSocketResult SAL_CALL osl_psz_getLocalHostname (
     return osl_Socket_Error;
 }
 
-/*****************************************************************************/
-/* osl_resolveHostname */
-/*****************************************************************************/
 oslSocketAddr SAL_CALL osl_resolveHostname(rtl_uString *ustrHostname)
 {
     oslSocketAddr Addr;
@@ -1215,9 +1154,6 @@ oslSocketAddr SAL_CALL osl_psz_resolveHostname(const sal_Char* pszHostname)
     return ((oslSocketAddr)NULL);
 }
 
-/*****************************************************************************/
-/* osl_getServicePort */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_getServicePort(rtl_uString *ustrServicename, rtl_uString *ustrProtocol)
 {
     sal_Int32 nPort;
@@ -1276,17 +1212,11 @@ sal_Int32 SAL_CALL osl_psz_getServicePort(const sal_Char* pszServicename,
     return OSL_INVALID_PORT;
 }
 
-/*****************************************************************************/
-/* osl_destroySocketAddr */
-/*****************************************************************************/
 void SAL_CALL osl_destroySocketAddr(oslSocketAddr pAddr)
 {
     __osl_destroySocketAddr( pAddr );
 }
 
-/*****************************************************************************/
-/* osl_getFamilyOfSocketAddr */
-/*****************************************************************************/
 oslAddrFamily SAL_CALL osl_getFamilyOfSocketAddr(oslSocketAddr pAddr)
 {
     OSL_ASSERT(pAddr);
@@ -1297,9 +1227,6 @@ oslAddrFamily SAL_CALL osl_getFamilyOfSocketAddr(oslSocketAddr pAddr)
         return osl_Socket_FamilyInvalid;
 }
 
-/*****************************************************************************/
-/* osl_getInetPortOfSocketAddr */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_getInetPortOfSocketAddr(oslSocketAddr pAddr)
 {
     OSL_ASSERT(pAddr);
@@ -1313,9 +1240,6 @@ sal_Int32 SAL_CALL osl_getInetPortOfSocketAddr(oslSocketAddr pAddr)
     return OSL_INVALID_PORT;
 }
 
-/*****************************************************************************/
-/* osl_setInetPortOfSocketAddr */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_setInetPortOfSocketAddr(oslSocketAddr pAddr, sal_Int32 Port)
 {
     OSL_ASSERT(pAddr);
@@ -1333,9 +1257,6 @@ sal_Bool SAL_CALL osl_setInetPortOfSocketAddr(oslSocketAddr pAddr, sal_Int32 Por
     return sal_False;
 }
 
-/*****************************************************************************/
-/* osl_getHostnameOfSocketAddr */
-/*****************************************************************************/
 oslSocketResult SAL_CALL osl_getHostnameOfSocketAddr(oslSocketAddr Addr, rtl_uString **ustrHostname)
 {
     oslSocketResult Result;
@@ -1409,9 +1330,6 @@ oslSocketResult SAL_CALL osl_psz_getDottedInetAddrOfSocketAddr(oslSocketAddr pAd
     return osl_Socket_Error;
 }
 
-/*****************************************************************************/
-/* osl_createSocket  */
-/*****************************************************************************/
 oslSocket SAL_CALL osl_createSocket(oslAddrFamily   Family,
                            oslSocketType    Type,
                            oslProtocol      Protocol)
@@ -1481,11 +1399,6 @@ void SAL_CALL osl_releaseSocket( oslSocket pSocket )
     }
 }
 
-
-
-/*****************************************************************************/
-/* osl_closeSocket  */
-/*****************************************************************************/
 void SAL_CALL osl_closeSocket(oslSocket pSocket)
 {
     int nRet;
@@ -1579,9 +1492,6 @@ oslSocketAddr SAL_CALL osl_getLocalAddrOfSocket(oslSocket pSocket)
     return pAddr;
 }
 
-/*****************************************************************************/
-/* osl_getPeerAddrOfSocket  */
-/*****************************************************************************/
 oslSocketAddr SAL_CALL osl_getPeerAddrOfSocket(oslSocket pSocket)
 {
     socklen_t AddrLen;
@@ -1604,9 +1514,6 @@ oslSocketAddr SAL_CALL osl_getPeerAddrOfSocket(oslSocket pSocket)
     return __osl_createSocketAddrFromSystem( &Addr );
 }
 
-/*****************************************************************************/
-/* osl_bindAddrToSocket  */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_bindAddrToSocket(oslSocket pSocket,
                              oslSocketAddr pAddr)
 {
@@ -1631,10 +1538,6 @@ sal_Bool SAL_CALL osl_bindAddrToSocket(oslSocket pSocket,
     return sal_True;
 }
 
-
-/*****************************************************************************/
-/* osl_listenOnSocket  */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_listenOnSocket(oslSocket pSocket,
                            sal_Int32 MaxPendingConnections)
 {
@@ -1661,10 +1564,6 @@ sal_Bool SAL_CALL osl_listenOnSocket(oslSocket pSocket,
     return sal_True;
 }
 
-
-/*****************************************************************************/
-/* osl_connectSocketTo  */
-/*****************************************************************************/
 oslSocketResult SAL_CALL osl_connectSocketTo(oslSocket pSocket,
                                     oslSocketAddr pAddr,
                                     const TimeValue* pTimeout)
@@ -1800,9 +1699,6 @@ oslSocketResult SAL_CALL osl_connectSocketTo(oslSocket pSocket,
 }
 
 
-/*****************************************************************************/
-/* osl_acceptConnectionOnSocket  */
-/*****************************************************************************/
 oslSocket SAL_CALL osl_acceptConnectionOnSocket(oslSocket pSocket,
                         oslSocketAddr* ppAddr)
 {
@@ -1892,9 +1788,6 @@ oslSocket SAL_CALL osl_acceptConnectionOnSocket(oslSocket pSocket,
     return pConnectionSockImpl;
 }
 
-/*****************************************************************************/
-/* osl_receiveSocket  */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_receiveSocket(oslSocket pSocket,
                           void* pBuffer,
                           sal_uInt32 BytesToRead,
@@ -1933,9 +1826,6 @@ sal_Int32 SAL_CALL osl_receiveSocket(oslSocket pSocket,
 }
 
 
-/*****************************************************************************/
-/* osl_receiveFromSocket  */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_receiveFromSocket(oslSocket pSocket,
                               oslSocketAddr pSenderAddr,
                               void* pBuffer,
@@ -1980,10 +1870,6 @@ sal_Int32 SAL_CALL osl_receiveFromSocket(oslSocket pSocket,
     return nRead;
 }
 
-
-/*****************************************************************************/
-/* osl_sendSocket  */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_sendSocket(oslSocket pSocket,
                        const void* pBuffer,
                        sal_uInt32 BytesToSend,
@@ -2022,9 +1908,6 @@ sal_Int32 SAL_CALL osl_sendSocket(oslSocket pSocket,
     return nWritten;
 }
 
-/*****************************************************************************/
-/* osl_sendToSocket  */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_sendToSocket(oslSocket pSocket,
                          oslSocketAddr ReceiverAddr,
                          const void* pBuffer,
@@ -2073,9 +1956,6 @@ sal_Int32 SAL_CALL osl_sendToSocket(oslSocket pSocket,
     return nWritten;
 }
 
-/*****************************************************************************/
-/* osl_readSocket  */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_readSocket (
     oslSocket pSocket, void *pBuffer, sal_Int32 n )
 {
@@ -2108,9 +1988,6 @@ sal_Int32 SAL_CALL osl_readSocket (
     return BytesRead;
 }
 
-/*****************************************************************************/
-/* osl_writeSocket  */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_writeSocket(
     oslSocket pSocket, const void *pBuffer, sal_Int32 n )
 {
@@ -2141,10 +2018,6 @@ sal_Int32 SAL_CALL osl_writeSocket(
     return BytesSend;
 }
 
-/*****************************************************************************/
-/* __osl_socket_poll */
-/*****************************************************************************/
-
 #ifdef HAVE_POLL_H /* poll() */
 
 sal_Bool __osl_socket_poll (
@@ -2243,9 +2116,6 @@ sal_Bool __osl_socket_poll (
 
 #endif /* HAVE_POLL_H */
 
-/*****************************************************************************/
-/* osl_isReceiveReady  */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_isReceiveReady (
     oslSocket pSocket, const TimeValue* pTimeout)
 {
@@ -2259,9 +2129,6 @@ sal_Bool SAL_CALL osl_isReceiveReady (
     return __osl_socket_poll (pSocket, pTimeout, POLLIN);
 }
 
-/*****************************************************************************/
-/* osl_isSendReady  */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_isSendReady (
     oslSocket pSocket, const TimeValue* pTimeout)
 {
@@ -2275,9 +2142,6 @@ sal_Bool SAL_CALL osl_isSendReady (
     return __osl_socket_poll (pSocket, pTimeout, POLLOUT);
 }
 
-/*****************************************************************************/
-/* osl_isExceptionPending  */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_isExceptionPending (
     oslSocket pSocket, const TimeValue* pTimeout)
 {
@@ -2291,9 +2155,6 @@ sal_Bool SAL_CALL osl_isExceptionPending (
     return __osl_socket_poll (pSocket, pTimeout, POLLPRI);
 }
 
-/*****************************************************************************/
-/* osl_shutdownSocket  */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_shutdownSocket(oslSocket pSocket,
                            oslSocketDirection Direction)
 {
@@ -2317,9 +2178,6 @@ sal_Bool SAL_CALL osl_shutdownSocket(oslSocket pSocket,
 }
 
 
-/*****************************************************************************/
-/* osl_getSocketOption  */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_getSocketOption(oslSocket pSocket,
                             oslSocketOptionLevel    Level,
                             oslSocketOption         Option,
@@ -2349,9 +2207,6 @@ sal_Int32 SAL_CALL osl_getSocketOption(oslSocket pSocket,
     return BufferLen;
 }
 
-/*****************************************************************************/
-/* osl_setSocketOption  */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_setSocketOption(oslSocket pSocket,
                             oslSocketOptionLevel    Level,
                             oslSocketOption         Option,
@@ -2383,9 +2238,6 @@ sal_Bool SAL_CALL osl_setSocketOption(oslSocket pSocket,
     return sal_True;
 }
 
-/*****************************************************************************/
-/* osl_enableNonBlockingMode  */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_enableNonBlockingMode(oslSocket pSocket,
                                   sal_Bool On)
 {
@@ -2418,9 +2270,6 @@ sal_Bool SAL_CALL osl_enableNonBlockingMode(oslSocket pSocket,
     return sal_True;
 }
 
-/*****************************************************************************/
-/* osl_isNonBlockingMode  */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_isNonBlockingMode(oslSocket pSocket)
 {
     int flags;
@@ -2441,9 +2290,6 @@ sal_Bool SAL_CALL osl_isNonBlockingMode(oslSocket pSocket)
         return sal_True;
 }
 
-/*****************************************************************************/
-/* osl_getSocketType  */
-/*****************************************************************************/
 oslSocketType SAL_CALL osl_getSocketType(oslSocket pSocket)
 {
     int Type=0;
@@ -2472,9 +2318,6 @@ oslSocketType SAL_CALL osl_getSocketType(oslSocket pSocket)
 
 }
 
-/*****************************************************************************/
-/* osl_getLastSocketErrorDescription  */
-/*****************************************************************************/
 void SAL_CALL osl_getLastSocketErrorDescription(oslSocket Socket, rtl_uString **ustrError)
 {
     sal_Char pszError[1024];
@@ -2504,9 +2347,6 @@ void SAL_CALL osl_psz_getLastSocketErrorDescription(oslSocket pSocket, sal_Char*
     return;
 }
 
-/*****************************************************************************/
-/* osl_getLastSocketError  */
-/*****************************************************************************/
 oslSocketError SAL_CALL osl_getLastSocketError(oslSocket pSocket)
 {
     if ( pSocket == 0 )
@@ -2517,9 +2357,6 @@ oslSocketError SAL_CALL osl_getLastSocketError(oslSocket pSocket)
     return ERROR_FROM_NATIVE(pSocket->m_nLastError);
 }
 
-/*****************************************************************************/
-/* SocketSet                                                                 */
-/*****************************************************************************/
 typedef struct _TSocketSetImpl
 {
     int     m_MaxHandle;    /* for select(), the largest descriptor in the set */
@@ -2527,9 +2364,6 @@ typedef struct _TSocketSetImpl
 
 } TSocketSetImpl;
 
-/*****************************************************************************/
-/* osl_createSocketSet  */
-/*****************************************************************************/
 oslSocketSet SAL_CALL osl_createSocketSet()
 {
     TSocketSetImpl* pSet;
@@ -2547,18 +2381,12 @@ oslSocketSet SAL_CALL osl_createSocketSet()
     return (oslSocketSet)pSet;
 }
 
-/*****************************************************************************/
-/* osl_destroySocketSet  */
-/*****************************************************************************/
 void SAL_CALL osl_destroySocketSet(oslSocketSet Set)
 {
     if(Set)
         free(Set);
 }
 
-/*****************************************************************************/
-/* osl_clearSocketSet  */
-/*****************************************************************************/
 void SAL_CALL osl_clearSocketSet(oslSocketSet Set)
 {
     TSocketSetImpl* pSet;
@@ -2574,9 +2402,6 @@ void SAL_CALL osl_clearSocketSet(oslSocketSet Set)
     FD_ZERO(&pSet->m_Set);
 }
 
-/*****************************************************************************/
-/* osl_addToSocketSet  */
-/*****************************************************************************/
 void SAL_CALL osl_addToSocketSet(oslSocketSet Set, oslSocket pSocket)
 {
     TSocketSetImpl* pSet;
@@ -2598,9 +2423,6 @@ void SAL_CALL osl_addToSocketSet(oslSocketSet Set, oslSocket pSocket)
 
 }
 
-/*****************************************************************************/
-/* osl_removeFromSocketSet  */
-/*****************************************************************************/
 void SAL_CALL osl_removeFromSocketSet(oslSocketSet Set, oslSocket pSocket)
 {
     TSocketSetImpl* pSet;
@@ -2630,9 +2452,6 @@ void SAL_CALL osl_removeFromSocketSet(oslSocketSet Set, oslSocket pSocket)
     FD_CLR(pSocket->m_Socket, &pSet->m_Set);
 }
 
-/*****************************************************************************/
-/* osl_isInSocketSet  */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_isInSocketSet(oslSocketSet Set, oslSocket pSocket)
 {
     TSocketSetImpl* pSet;
@@ -2649,9 +2468,6 @@ sal_Bool SAL_CALL osl_isInSocketSet(oslSocketSet Set, oslSocket pSocket)
     return (FD_ISSET(pSocket->m_Socket, &pSet->m_Set) != 0);
 }
 
-/*****************************************************************************/
-/* osl_demultiplexSocketEvents  */
-/*****************************************************************************/
 sal_Int32 SAL_CALL osl_demultiplexSocketEvents(oslSocketSet IncomingSet,
                                     oslSocketSet OutgoingSet,
                                     oslSocketSet OutOfBandSet,
diff --git a/sal/osl/unx/tempfile.c b/sal/osl/unx/tempfile.c
index b36054ef0b9b..2aad4bbba613 100644
--- a/sal/osl/unx/tempfile.c
+++ b/sal/osl/unx/tempfile.c
@@ -269,10 +269,6 @@ static oslFileError osl_create_temp_file_impl_(
     return osl_error;
 }
 
-/*****************************************************************
- * osl_createTempFile
- *****************************************************************/
-
 oslFileError SAL_CALL osl_createTempFile(
     rtl_uString*   pustrDirectoryURL,
     oslFileHandle* pHandle,
diff --git a/sal/osl/unx/thread.c b/sal/osl/unx/thread.c
index c137b24b80a6..598fd92c9b7b 100644
--- a/sal/osl/unx/thread.c
+++ b/sal/osl/unx/thread.c
@@ -135,18 +135,12 @@ static sal_uInt16 insertThreadId (pthread_t hThread);
 static sal_uInt16 lookupThreadId (pthread_t hThread);
 static void       removeThreadId (pthread_t hThread);
 
-/*****************************************************************************/
-/* osl_thread_init_Impl */
-/*****************************************************************************/
 static void osl_thread_init_Impl (void)
 {
     osl_thread_priority_init_Impl();
     osl_thread_textencoding_init_Impl();
 }
 
-/*****************************************************************************/
-/* osl_thread_construct_Impl */
-/*****************************************************************************/
 Thread_Impl* osl_thread_construct_Impl (void)
 {
     Thread_Impl* pImpl = malloc (sizeof(Thread_Impl));
@@ -160,9 +154,6 @@ Thread_Impl* osl_thread_construct_Impl (void)
     return (pImpl);
 }
 
-/*****************************************************************************/
-/* osl_thread_destruct_Impl */
-/*****************************************************************************/
 static void osl_thread_destruct_Impl (Thread_Impl ** ppImpl)
 {
     OSL_ASSERT(ppImpl);
@@ -176,9 +167,6 @@ static void osl_thread_destruct_Impl (Thread_Impl ** ppImpl)
     }
 }
 
-/*****************************************************************************/
-/* osl_thread_cleanup_Impl */
-/*****************************************************************************/
 static void osl_thread_cleanup_Impl (Thread_Impl * pImpl)
 {
     pthread_t thread;
@@ -208,9 +196,6 @@ static void osl_thread_cleanup_Impl (Thread_Impl * pImpl)
     }
 }
 
-/*****************************************************************************/
-/* osl_thread_start_Impl */
-/*****************************************************************************/
 static void* osl_thread_start_Impl (void* pData)
 {
     int terminate;
@@ -260,9 +245,6 @@ static void* osl_thread_start_Impl (void* pData)
     return (0);
 }
 
-/*****************************************************************************/
-/* osl_thread_create_Impl */
-/*****************************************************************************/
 static oslThread osl_thread_create_Impl (
     oslWorkerFunction pWorker,
     void*             pThreadData,
@@ -329,9 +311,6 @@ static oslThread osl_thread_create_Impl (
     return ((oslThread)(pImpl));
 }
 
-/*****************************************************************************/
-/* osl_createThread */
-/*****************************************************************************/
 oslThread osl_createThread (
     oslWorkerFunction pWorker,
     void *            pThreadData)
@@ -342,9 +321,6 @@ oslThread osl_createThread (
         THREADIMPL_FLAGS_ATTACHED);
 }
 
-/*****************************************************************************/
-/* osl_createSuspendedThread */
-/*****************************************************************************/
 oslThread osl_createSuspendedThread (
     oslWorkerFunction pWorker,
     void *            pThreadData)
@@ -356,9 +332,6 @@ oslThread osl_createSuspendedThread (
         THREADIMPL_FLAGS_SUSPENDED );
 }
 
-/*****************************************************************************/
-/* osl_destroyThread */
-/*****************************************************************************/
 void SAL_CALL osl_destroyThread(oslThread Thread)
 {
     if (Thread != NULL) {
@@ -374,9 +347,6 @@ void SAL_CALL osl_destroyThread(oslThread Thread)
     }
 }
 
-/*****************************************************************************/
-/* osl_resumeThread */
-/*****************************************************************************/
 void SAL_CALL osl_resumeThread(oslThread Thread)
 {
     Thread_Impl* pImpl= (Thread_Impl*)Thread;
@@ -397,9 +367,6 @@ void SAL_CALL osl_resumeThread(oslThread Thread)
     pthread_mutex_unlock (&(pImpl->m_Lock));
 }
 
-/*****************************************************************************/
-/* osl_suspendThread */
-/*****************************************************************************/
 void SAL_CALL osl_suspendThread(oslThread Thread)
 {
     Thread_Impl* pImpl= (Thread_Impl*)Thread;
@@ -425,9 +392,6 @@ void SAL_CALL osl_suspendThread(oslThread Thread)
     pthread_mutex_unlock (&(pImpl->m_Lock));
 }
 
-/*****************************************************************************/
-/* osl_isThreadRunning */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_isThreadRunning(const oslThread Thread)
 {
     sal_Bool active;
@@ -443,9 +407,6 @@ sal_Bool SAL_CALL osl_isThreadRunning(const oslThread Thread)
     return (active);
 }
 
-/*****************************************************************************/
-/* osl_joinWithThread */
-/*****************************************************************************/
 void SAL_CALL osl_joinWithThread(oslThread Thread)
 {
     pthread_t thread;
@@ -476,9 +437,6 @@ void SAL_CALL osl_joinWithThread(oslThread Thread)
     }
 }
 
-/*****************************************************************************/
-/* osl_terminateThread */
-/*****************************************************************************/
 void SAL_CALL osl_terminateThread(oslThread Thread)
 {
     Thread_Impl* pImpl= (Thread_Impl*)Thread;
@@ -501,9 +459,6 @@ void SAL_CALL osl_terminateThread(oslThread Thread)
     pthread_mutex_unlock (&(pImpl->m_Lock));
 }
 
-/*****************************************************************************/
-/* osl_scheduleThread */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_scheduleThread(oslThread Thread)
 {
     int terminate;
@@ -532,9 +487,6 @@ sal_Bool SAL_CALL osl_scheduleThread(oslThread Thread)
     return (terminate == 0);
 }
 
-/*****************************************************************************/
-/* osl_waitThread */
-/*****************************************************************************/
 void SAL_CALL osl_waitThread(const TimeValue* pDelay)
 {
     if (pDelay)
@@ -875,9 +827,6 @@ void SAL_CALL osl_setThreadPriority (
 #endif /* NO_PTHREAD_PRIORITY */
 }
 
-/*****************************************************************************/
-/* osl_getThreadPriority */
-/*****************************************************************************/
 oslThreadPriority SAL_CALL osl_getThreadPriority(const oslThread Thread)
 {
 #ifndef NO_PTHREAD_PRIORITY
@@ -944,9 +893,6 @@ typedef struct _wrapper_pthread_key
     oslThreadKeyCallbackFunction pfnCallback;
 } wrapper_pthread_key;
 
-/*****************************************************************************/
-/* osl_createThreadKey */
-/*****************************************************************************/
 oslThreadKey SAL_CALL osl_createThreadKey( oslThreadKeyCallbackFunction pCallback )
 {
     wrapper_pthread_key *pKey = (wrapper_pthread_key*)rtl_allocateMemory(sizeof(wrapper_pthread_key));
@@ -965,9 +911,6 @@ oslThreadKey SAL_CALL osl_createThreadKey( oslThreadKeyCallbackFunction pCallbac
     return ((oslThreadKey)pKey);
 }
 
-/*****************************************************************************/
-/* osl_destroyThreadKey */
-/*****************************************************************************/
 void SAL_CALL osl_destroyThreadKey(oslThreadKey Key)
 {
     wrapper_pthread_key *pKey = (wrapper_pthread_key*)Key;
@@ -978,18 +921,12 @@ void SAL_CALL osl_destroyThreadKey(oslThreadKey Key)
     }
 }
 
-/*****************************************************************************/
-/* osl_getThreadKeyData */
-/*****************************************************************************/
 void* SAL_CALL osl_getThreadKeyData(oslThreadKey Key)
 {
     wrapper_pthread_key *pKey = (wrapper_pthread_key*)Key;
     return pKey ? pthread_getspecific(pKey->m_key) : NULL;
 }
 
-/*****************************************************************************/
-/* osl_setThreadKeyData */
-/*****************************************************************************/
 sal_Bool SAL_CALL osl_setThreadKeyData(oslThreadKey Key, void *pData)
 {
     sal_Bool bRet;
@@ -1040,9 +977,6 @@ static void osl_thread_textencoding_init_Impl (void)
     g_thread.m_textencoding.m_default = defaultEncoding;
 }
 
-/*****************************************************************************/
-/* osl_getThreadTextEncoding */
-/*****************************************************************************/
 rtl_TextEncoding SAL_CALL osl_getThreadTextEncoding()
 {
     rtl_TextEncoding threadEncoding;
@@ -1059,9 +993,6 @@ rtl_TextEncoding SAL_CALL osl_getThreadTextEncoding()
     return threadEncoding;
 }
 
-/*****************************************************************************/
-/* osl_setThreadTextEncoding */
-/*****************************************************************************/
 rtl_TextEncoding osl_setThreadTextEncoding(rtl_TextEncoding Encoding)
 {
     rtl_TextEncoding oldThreadEncoding = osl_getThreadTextEncoding();
diff --git a/sal/osl/unx/time.c b/sal/osl/unx/time.c
index 14d4ec02d257..61b6e39ae6dd 100644
--- a/sal/osl/unx/time.c
+++ b/sal/osl/unx/time.c
@@ -53,10 +53,6 @@ typedef struct timeval osl_time_t;
 static osl_time_t startTime;
 
 
-/*--------------------------------------------------
- * osl_getSystemTime
- *-------------------------------------------------*/
-
 sal_Bool SAL_CALL osl_getSystemTime(TimeValue* tv)
 {
 #ifdef __MACH__
@@ -94,10 +90,6 @@ sal_Bool SAL_CALL osl_getSystemTime(TimeValue* tv)
 }
 
 
-/*--------------------------------------------------
- * osl_getDateTimeFromTimeValue
- *-------------------------------------------------*/
-
 sal_Bool SAL_CALL osl_getDateTimeFromTimeValue( const TimeValue* pTimeVal, oslDateTime* pDateTime )
 {
     struct tm *pSystemTime;
@@ -128,10 +120,6 @@ sal_Bool SAL_CALL osl_getDateTimeFromTimeValue( const TimeValue* pTimeVal, oslDa
     return sal_False;
 }
 
-/*--------------------------------------------------
- * osl_getTimeValueFromDateTime
- *--------------------------------------------------*/
-
 sal_Bool SAL_CALL osl_getTimeValueFromDateTime( const oslDateTime* pDateTime, TimeValue* pTimeVal )
 {
     struct tm   aTime;
@@ -199,10 +187,6 @@ sal_Bool SAL_CALL osl_getTimeValueFromDateTime( const oslDateTime* pDateTime, Ti
 }
 
 
-/*--------------------------------------------------
- * osl_getLocalTimeFromSystemTime
- *--------------------------------------------------*/
-
 sal_Bool SAL_CALL osl_getLocalTimeFromSystemTime( const TimeValue* pSystemTimeVal, TimeValue* pLocalTimeVal )
 {
     struct tm *pLocalTime;
@@ -236,10 +220,6 @@ sal_Bool SAL_CALL osl_getLocalTimeFromSystemTime( const TimeValue* pSystemTimeVa
     return sal_False;
 }
 
-/*--------------------------------------------------
- * osl_getSystemTimeFromLocalTime
- *--------------------------------------------------*/
-
 sal_Bool SAL_CALL osl_getSystemTimeFromLocalTime( const TimeValue* pLocalTimeVal, TimeValue* pSystemTimeVal )
 {
     struct tm *pLocalTime;
diff --git a/sal/osl/unx/util.c b/sal/osl/unx/util.c
index 6118a5f37642..d9b3a93313eb 100644
--- a/sal/osl/unx/util.c
+++ b/sal/osl/unx/util.c
@@ -34,18 +34,10 @@
 #include "osl/diagnose.h"
 
 
-/*****************************************************************************/
-/* Static Module Functions */
-/*****************************************************************************/
-
 static int   osl_getHWAddr(const char *ifname, char* hard_addr);
 static int   osl_checkAddr(const char* addr);
 
 
-/*****************************************************************************/
-/* osl_getEthernetAddress */
-/*****************************************************************************/
-
 sal_Bool SAL_CALL osl_getEthernetAddress( sal_uInt8 * pAddr )
 {
 #ifdef SOLARIS
@@ -111,10 +103,6 @@ sal_Bool SAL_CALL osl_getEthernetAddress( sal_uInt8 * pAddr )
 }
 
 
-/*****************************************************************************/
-/* osl_getHWAddr */
-/*****************************************************************************/
-
 static int osl_getHWAddr(const char *ifname, char* hard_addr)
 {
     int ret=0;
@@ -197,10 +185,6 @@ static int osl_getHWAddr(const char *ifname, char* hard_addr)
 }
 
 
-/*****************************************************************************/
-/* osl_checkAddr */
-/*****************************************************************************/
-
 static int osl_checkAddr(const char* addr)
 {
     if (addr[0]==0 && addr[1]==0 &&
@@ -219,10 +203,6 @@ static int osl_checkAddr(const char* addr)
 #include <sys/types.h>
 #include <sys/processor.h>
 
-/*****************************************************************************/
-/* osl_InitSparcV9 */
-/*****************************************************************************/
-
 void osl_InterlockedCountSetV9(sal_Bool bV9);
 
 /*