Remove visual noise from sal

Change-Id: Idf07c7d31c0a523f929aded9ff3183a3f01b16b9
Reviewed-on: https://gerrit.libreoffice.org/8297
Reviewed-by: Caolán McNamara <caolanm@redhat.com>
Tested-by: Caolán McNamara <caolanm@redhat.com>

7 files changed, 152 insertions, 152 deletions

diff --git a/sal/osl/w32/dllentry.c b/sal/osl/w32/dllentry.c
index 96d752546be2..79dbf6734fbe 100644
--- a/sal/osl/w32/dllentry.c
+++ b/sal/osl/w32/dllentry.c
@@ -35,9 +35,9 @@
 
 #include "internal/rtllifecycle.h"
 
-//------------------------------------------------------------------------------
+
 // externals
-//------------------------------------------------------------------------------
+
 
 extern DWORD            g_dwTLSTextEncodingIndex;
 extern void SAL_CALL    _osl_callThreadKeyCallbackOnThreadDetach(void);
@@ -304,7 +304,7 @@ BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
                 {
                     // No error check, it works or it does not
                     // Thread should only be started for headless mode, see desktop/win32/source/officeloader.cxx
-                    CreateThread( NULL, 0, ParentMonitorThreadProc, (LPVOID)dwParentProcessId, 0, &dwThreadId ); //
+                    CreateThread( NULL, 0, ParentMonitorThreadProc, (LPVOID)dwParentProcessId, 0, &dwThreadId );
                 }
             }
 
diff --git a/sal/osl/w32/file.cxx b/sal/osl/w32/file.cxx
index 30a4f550a1f5..dcea2fb3f5c5 100644
--- a/sal/osl/w32/file.cxx
+++ b/sal/osl/w32/file.cxx
@@ -50,9 +50,9 @@
 #undef min
 #endif
 
-//##################################################################
+
 // File handle implementation
-//##################################################################
+
 struct FileHandle_Impl
 {
     CRITICAL_SECTION m_mutex;
@@ -651,9 +651,9 @@ oslFileError FileHandle_Impl::syncFile()
     return (result);
 }
 
-//##################################################################
+
 // File I/O functions
-//##################################################################
+
 
 extern "C" oslFileHandle
 SAL_CALL osl_createFileHandleFromOSHandle (
@@ -694,7 +694,7 @@ SAL_CALL osl_createFileHandleFromOSHandle (
     return (oslFileHandle)(pImpl);
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_openFile(
     rtl_uString *   strPath,
@@ -735,7 +735,7 @@ SAL_CALL osl_openFile(
     return (result);
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_syncFile(oslFileHandle Handle)
 {
@@ -755,7 +755,7 @@ SAL_CALL osl_syncFile(oslFileHandle Handle)
     return osl_File_E_None;
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_getFileOSHandle(
     oslFileHandle  Handle,
@@ -771,7 +771,7 @@ SAL_CALL osl_getFileOSHandle(
     return osl_File_E_None;
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_closeFile(oslFileHandle Handle)
 {
@@ -798,7 +798,7 @@ SAL_CALL osl_closeFile(oslFileHandle Handle)
     return (result);
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_mapFile(
     oslFileHandle Handle,
@@ -871,7 +871,7 @@ SAL_CALL osl_mapFile(
     return osl_File_E_None;
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_unmapFile(void* pAddr, sal_uInt64 /* uLength */)
 {
@@ -884,14 +884,14 @@ SAL_CALL osl_unmapFile(void* pAddr, sal_uInt64 /* uLength */)
     return osl_File_E_None;
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_unmapMappedFile(oslFileHandle /* Handle */, void* pAddr, sal_uInt64 uLength)
 {
     return osl_unmapFile( pAddr, uLength );
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_readLine(
     oslFileHandle   Handle,
@@ -911,7 +911,7 @@ SAL_CALL osl_readLine(
     return (result);
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_readFile(
     oslFileHandle Handle,
@@ -932,7 +932,7 @@ SAL_CALL osl_readFile(
     return (result);
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_writeFile(
     oslFileHandle Handle,
@@ -954,7 +954,7 @@ SAL_CALL osl_writeFile(
     return (result);
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_readFileAt(
     oslFileHandle Handle,
@@ -980,7 +980,7 @@ SAL_CALL osl_readFileAt(
     return pImpl->readFileAt (nOffset, pBuffer, uBytesRequested, pBytesRead);
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_writeFileAt(
     oslFileHandle Handle,
@@ -1006,7 +1006,7 @@ SAL_CALL osl_writeFileAt(
     return pImpl->writeFileAt (nOffset, pBuffer, uBytesToWrite, pBytesWritten);
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_isEndOfFile (oslFileHandle Handle, sal_Bool *pIsEOF)
 {
@@ -1020,7 +1020,7 @@ SAL_CALL osl_isEndOfFile (oslFileHandle Handle, sal_Bool *pIsEOF)
     return osl_File_E_None;
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_getFilePos(oslFileHandle Handle, sal_uInt64 *pPos)
 {
@@ -1033,7 +1033,7 @@ SAL_CALL osl_getFilePos(oslFileHandle Handle, sal_uInt64 *pPos)
     return osl_File_E_None;
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_setFilePos(oslFileHandle Handle, sal_uInt32 uHow, sal_Int64 uOffset)
 {
@@ -1077,7 +1077,7 @@ SAL_CALL osl_setFilePos(oslFileHandle Handle, sal_uInt32 uHow, sal_Int64 uOffset
     return pImpl->setPos (nPos + nOffset);
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_getFileSize (oslFileHandle Handle, sal_uInt64 *pSize)
 {
@@ -1091,7 +1091,7 @@ SAL_CALL osl_getFileSize (oslFileHandle Handle, sal_uInt64 *pSize)
     return osl_File_E_None;
 }
 
-//#############################################
+
 oslFileError
 SAL_CALL osl_setFileSize (oslFileHandle Handle, sal_uInt64 uSize)
 {
@@ -1115,11 +1115,11 @@ SAL_CALL osl_setFileSize (oslFileHandle Handle, sal_uInt64 uSize)
     return pImpl->setSize (uSize);
 }
 
-//##################################################################
+
 // File handling functions
-//##################################################################
 
-//#############################################
+
+
 oslFileError SAL_CALL osl_removeFile( rtl_uString* strPath )
 {
     rtl_uString *strSysPath = NULL;
@@ -1137,7 +1137,7 @@ oslFileError SAL_CALL osl_removeFile( rtl_uString* strPath )
     return error;
 }
 
-//#############################################
+
 oslFileError SAL_CALL osl_copyFile( rtl_uString* strPath, rtl_uString *strDestPath )
 {
     rtl_uString *strSysPath = NULL, *strSysDestPath = NULL;
@@ -1165,7 +1165,7 @@ oslFileError SAL_CALL osl_copyFile( rtl_uString* strPath, rtl_uString *strDestPa
     return error;
 }
 
-//#############################################
+
 oslFileError SAL_CALL osl_moveFile( rtl_uString* strPath, rtl_uString *strDestPath )
 {
     rtl_uString *strSysPath = NULL, *strSysDestPath = NULL;
diff --git a/sal/osl/w32/file_dirvol.cxx b/sal/osl/w32/file_dirvol.cxx
index 071e29447176..2f598720e787 100644
--- a/sal/osl/w32/file_dirvol.cxx
+++ b/sal/osl/w32/file_dirvol.cxx
@@ -39,12 +39,12 @@
 #include <ctype.h>
 #endif
 
-//#####################################################
+
 static const wchar_t UNC_PREFIX[] = L"\\\\";
 static const wchar_t BACKSLASH = '\\';
 static const wchar_t SLASH = '/';
 
-//#####################################################
+
 extern "C" BOOL TimeValueToFileTime(const TimeValue *cpTimeVal, FILETIME *pFTime)
 {
     SYSTEMTIME  BaseSysTime;
@@ -77,7 +77,7 @@ extern "C" BOOL TimeValueToFileTime(const TimeValue *cpTimeVal, FILETIME *pFTime
     return fSuccess;
 }
 
-//#####################################################
+
 extern "C" BOOL FileTimeToTimeValue(const FILETIME *cpFTime, TimeValue *pTimeVal)
 {
     SYSTEMTIME  BaseSysTime;
@@ -108,10 +108,10 @@ extern "C" BOOL FileTimeToTimeValue(const FILETIME *cpFTime, TimeValue *pTimeVal
     return fSuccess;
 }
 
-//#####################################################
+
 namespace /* private */
 {
-    //#####################################################
+
     struct Component
     {
         Component() :
@@ -125,7 +125,7 @@ namespace /* private */
         const sal_Unicode* end_;
     };
 
-    //#####################################################
+
     struct UNCComponents
     {
         Component server_;
@@ -133,15 +133,15 @@ namespace /* private */
         Component resource_;
     };
 
-    //#####################################################
+
     inline bool is_UNC_path(const sal_Unicode* path)
     { return (0 == wcsncmp(UNC_PREFIX, reinterpret_cast<LPCWSTR>(path), SAL_N_ELEMENTS(UNC_PREFIX) - 1)); }
 
-    //#####################################################
+
     inline bool is_UNC_path(const rtl::OUString& path)
     { return is_UNC_path(path.getStr()); }
 
-    //#####################################################
+
     void parse_UNC_path(const sal_Unicode* path, UNCComponents* puncc)
     {
         OSL_PRECOND(is_UNC_path(path), "Precondition violated: No UNC path");
@@ -178,12 +178,12 @@ namespace /* private */
         "Postcondition violated: Invalid UNC path detected");
     }
 
-    //#####################################################
+
     void parse_UNC_path(const rtl::OUString& path, UNCComponents* puncc)
     { parse_UNC_path(path.getStr(), puncc); }
 
 
-    //#####################################################
+
     bool has_path_parent(const sal_Unicode* path)
     {
         // Has the given path a parent or are we already there,
@@ -203,17 +203,17 @@ namespace /* private */
         return has_parent;
     }
 
-    //#####################################################
+
     inline bool has_path_parent(const rtl::OUString& path)
     { return has_path_parent(path.getStr()); }
 
 } // end namespace private
 
-//#####################################################
+
 // volume handling functions
-//#####################################################
 
-//#####################################################
+
+
 oslFileError SAL_CALL osl_acquireVolumeDeviceHandle( oslVolumeDeviceHandle Handle )
 {
     if ( Handle )
@@ -225,7 +225,7 @@ oslFileError SAL_CALL osl_acquireVolumeDeviceHandle( oslVolumeDeviceHandle Handl
         return osl_File_E_INVAL;
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_releaseVolumeDeviceHandle( oslVolumeDeviceHandle Handle )
 {
     if ( Handle )
@@ -237,7 +237,7 @@ oslFileError SAL_CALL osl_releaseVolumeDeviceHandle( oslVolumeDeviceHandle Handl
         return osl_File_E_INVAL;
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_getVolumeDeviceMountPath( oslVolumeDeviceHandle Handle, rtl_uString **pstrPath )
 {
     if ( Handle && pstrPath )
@@ -249,9 +249,9 @@ oslFileError SAL_CALL osl_getVolumeDeviceMountPath( oslVolumeDeviceHandle Handle
         return osl_File_E_INVAL;
 }
 
-//##################################################################
+
 // directory handling functions
-//##################################################################
+
 
 #define DIRECTORYITEM_DRIVE     0
 #define DIRECTORYITEM_FILE      1
@@ -269,7 +269,7 @@ struct DirectoryItem_Impl
     int             nRefCount;
 };
 
-//#####################################################
+
 
 #define DIRECTORYTYPE_LOCALROOT     0
 #define DIRECTORYTYPE_NETROOT       1
@@ -285,7 +285,7 @@ struct Directory_Impl
     rtl_uString*    m_pDirectoryPath;
 };
 
-//#####################################################
+
 
 typedef struct tagDRIVEENUM
 {
@@ -294,7 +294,7 @@ typedef struct tagDRIVEENUM
     LPCTSTR lpCurrent;
 } DRIVEENUM, * PDRIVEENUM, FAR * LPDRIVEENUM;
 
-//#####################################################
+
 
 static HANDLE WINAPI OpenLogicalDrivesEnum(void)
 {
@@ -317,7 +317,7 @@ static HANDLE WINAPI OpenLogicalDrivesEnum(void)
     return pEnum ? (HANDLE)pEnum : INVALID_HANDLE_VALUE;
 }
 
-//#####################################################
+
 static BOOL WINAPI EnumLogicalDrives(HANDLE hEnum, LPTSTR lpBuffer)
 {
     BOOL        fSuccess = FALSE;
@@ -342,7 +342,7 @@ static BOOL WINAPI EnumLogicalDrives(HANDLE hEnum, LPTSTR lpBuffer)
     return fSuccess;
 }
 
-//#####################################################
+
 static BOOL WINAPI CloseLogicalDrivesEnum(HANDLE hEnum)
 {
     BOOL        fSuccess = FALSE;
@@ -359,14 +359,14 @@ static BOOL WINAPI CloseLogicalDrivesEnum(HANDLE hEnum)
     return fSuccess;
 }
 
-//#####################################################
+
 typedef struct tagDIRECTORY
 {
     HANDLE          hFind;
     WIN32_FIND_DATA aFirstData;
 } DIRECTORY, *PDIRECTORY, FAR *LPDIRECTORY;
 
-//#####################################################
+
 static HANDLE WINAPI OpenDirectory( rtl_uString* pPath)
 {
     LPDIRECTORY pDirectory = NULL;
@@ -413,7 +413,7 @@ static HANDLE WINAPI OpenDirectory( rtl_uString* pPath)
     return (HANDLE)pDirectory;
 }
 
-//#####################################################
+
 BOOL WINAPI EnumDirectory(HANDLE hDirectory, LPWIN32_FIND_DATA pFindData)
 {
     BOOL        fSuccess = FALSE;
@@ -449,7 +449,7 @@ BOOL WINAPI EnumDirectory(HANDLE hDirectory, LPWIN32_FIND_DATA pFindData)
     return fSuccess;
 }
 
-//#####################################################
+
 static BOOL WINAPI CloseDirectory(HANDLE hDirectory)
 {
     BOOL        fSuccess = FALSE;
@@ -468,7 +468,7 @@ static BOOL WINAPI CloseDirectory(HANDLE hDirectory)
     return fSuccess;
 }
 
-//#####################################################
+
 static oslFileError osl_openLocalRoot(
     rtl_uString *strDirectoryPath, oslDirectory *pDirectory)
 {
@@ -540,7 +540,7 @@ static oslFileError osl_openLocalRoot(
     return error;
 }
 
-//#####################################################
+
 static oslFileError SAL_CALL osl_openFileDirectory(
     rtl_uString *strDirectoryPath, oslDirectory *pDirectory)
 {
@@ -593,7 +593,7 @@ static oslFileError SAL_CALL osl_openFileDirectory(
     return error;
 }
 
-//#####################################################
+
 static oslFileError SAL_CALL osl_openNetworkServer(
     rtl_uString *strSysDirPath, oslDirectory *pDirectory)
 {
@@ -625,7 +625,7 @@ static oslFileError SAL_CALL osl_openNetworkServer(
     return oslTranslateFileError( dwError );
 }
 
-//#############################################
+
 static DWORD create_dir_with_callback(
     rtl_uString * dir_path,
     oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
@@ -652,7 +652,7 @@ static DWORD create_dir_with_callback(
     return GetLastError();
 }
 
-//#############################################
+
 static int path_make_parent(sal_Unicode* path)
 {
     /*  Cut off the last part of the given path to
@@ -671,7 +671,7 @@ static int path_make_parent(sal_Unicode* path)
     return (pos_last_backslash - path);
 }
 
-//#############################################
+
 static DWORD create_dir_recursively_(
     rtl_uString * dir_path,
     oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
@@ -702,7 +702,7 @@ static DWORD create_dir_recursively_(
     return create_dir_recursively_(dir_path, aDirectoryCreationCallbackFunc, pData);
 }
 
-//#############################################
+
 oslFileError SAL_CALL osl_createDirectoryPath(
     rtl_uString* aDirectoryUrl,
     oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
@@ -727,7 +727,7 @@ oslFileError SAL_CALL osl_createDirectoryPath(
         sys_path.pData, aDirectoryCreationCallbackFunc, pData));
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_createDirectory(rtl_uString* strPath)
 {
     rtl_uString *strSysPath = NULL;
@@ -765,7 +765,7 @@ oslFileError SAL_CALL osl_createDirectory(rtl_uString* strPath)
     return error;
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_removeDirectory(rtl_uString* strPath)
 {
     rtl_uString *strSysPath = NULL;
@@ -783,7 +783,7 @@ oslFileError SAL_CALL osl_removeDirectory(rtl_uString* strPath)
     return error;
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_openDirectory(rtl_uString *strDirectoryPath, oslDirectory *pDirectory)
 {
     oslFileError    error;
@@ -814,7 +814,7 @@ oslFileError SAL_CALL osl_openDirectory(rtl_uString *strDirectoryPath, oslDirect
     return error;
 }
 
-//#####################################################
+
 static oslFileError SAL_CALL osl_getNextNetResource(
     oslDirectory Directory, oslDirectoryItem *pItem, sal_uInt32 /*uHint*/ )
 {
@@ -860,7 +860,7 @@ static oslFileError SAL_CALL osl_getNextNetResource(
     }
 }
 
-//#####################################################
+
 static oslFileError SAL_CALL osl_getNextDrive(
     oslDirectory Directory, oslDirectoryItem *pItem, sal_uInt32 /*uHint*/ )
 {
@@ -902,7 +902,7 @@ static oslFileError SAL_CALL osl_getNextDrive(
     }
 }
 
-//#####################################################
+
 static oslFileError SAL_CALL osl_getNextFileItem(
     oslDirectory Directory, oslDirectoryItem *pItem, sal_uInt32 /*uHint*/)
 {
@@ -951,7 +951,7 @@ static oslFileError SAL_CALL osl_getNextFileItem(
     }
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_getNextDirectoryItem(
     oslDirectory Directory, oslDirectoryItem *pItem, sal_uInt32 uHint)
 {
@@ -979,7 +979,7 @@ oslFileError SAL_CALL osl_getNextDirectoryItem(
     }
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_closeDirectory(oslDirectory Directory)
 {
     Directory_Impl  *pDirImpl = (Directory_Impl *)Directory;
@@ -1017,7 +1017,7 @@ oslFileError SAL_CALL osl_closeDirectory(oslDirectory Directory)
     return eError;
 }
 
-//#####################################################
+
 /* Different types of paths */
 typedef enum _PATHTYPE
 {
@@ -1157,7 +1157,7 @@ oslFileError SAL_CALL osl_getDirectoryItem(rtl_uString *strFilePath, oslDirector
     return error;
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_acquireDirectoryItem( oslDirectoryItem Item )
 {
     DirectoryItem_Impl  *pItemImpl = (DirectoryItem_Impl *)Item;
@@ -1169,7 +1169,7 @@ oslFileError SAL_CALL osl_acquireDirectoryItem( oslDirectoryItem Item )
     return osl_File_E_None;
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_releaseDirectoryItem( oslDirectoryItem Item )
 {
     DirectoryItem_Impl  *pItemImpl = (DirectoryItem_Impl *)Item;
@@ -1211,19 +1211,19 @@ SAL_CALL osl_identicalDirectoryItem( oslDirectoryItem a, oslDirectoryItem b)
     return sal_False;
 }
 
-//#####################################################
+
 // volume / file info handling functions
-//#####################################################
 
-//#####################################################
+
+
 static inline bool is_floppy_A_present()
 { return (GetLogicalDrives() & 1); }
 
-//#####################################################
+
 static inline bool is_floppy_B_present()
 { return (GetLogicalDrives() & 2); }
 
-//#####################################################
+
 bool is_floppy_volume_mount_point(const rtl::OUString& path)
 {
     // determines if a volume mount point shows to a floppy
@@ -1251,7 +1251,7 @@ bool is_floppy_volume_mount_point(const rtl::OUString& path)
     return false;
 }
 
-//################################################
+
 static bool is_floppy_drive(const rtl::OUString& path)
 {
     static const LPCWSTR FLOPPY_DRV_LETTERS = TEXT("AaBb");
@@ -1266,7 +1266,7 @@ static bool is_floppy_drive(const rtl::OUString& path)
     return ((wcschr(FLOPPY_DRV_LETTERS, pszPath[0]) && (L':' == pszPath[1])) || is_floppy_volume_mount_point(path));
 }
 
-//#####################################################
+
 static bool is_volume_mount_point(const rtl::OUString& path)
 {
     rtl::OUString p(path);
@@ -1297,7 +1297,7 @@ static bool is_volume_mount_point(const rtl::OUString& path)
     return is_volume_root;
 }
 
-//#############################################
+
 static UINT get_volume_mount_point_drive_type(const rtl::OUString& path)
 {
     if (0 == path.getLength())
@@ -1313,13 +1313,13 @@ static UINT get_volume_mount_point_drive_type(const rtl::OUString& path)
     return DRIVE_NO_ROOT_DIR;
 }
 
-//#############################################
+
 static inline bool is_drivetype_request(sal_uInt32 field_mask)
 {
     return (field_mask & osl_VolumeInfo_Mask_Attributes);
 }
 
-//#############################################
+
 static oslFileError osl_get_drive_type(
     const rtl::OUString& path, oslVolumeInfo* pInfo)
 {
@@ -1366,7 +1366,7 @@ static oslFileError osl_get_drive_type(
     return osl_File_E_None;
 }
 
-//#############################################
+
 static inline bool is_volume_space_info_request(sal_uInt32 field_mask)
 {
     return (field_mask &
@@ -1375,7 +1375,7 @@ static inline bool is_volume_space_info_request(sal_uInt32 field_mask)
              osl_VolumeInfo_Mask_FreeSpace));
 }
 
-//#############################################
+
 static void get_volume_space_information(
     const rtl::OUString& path, oslVolumeInfo *pInfo)
 {
@@ -1394,7 +1394,7 @@ static void get_volume_space_information(
     }
 }
 
-//#############################################
+
 static inline bool is_filesystem_attributes_request(sal_uInt32 field_mask)
 {
     return (field_mask &
@@ -1404,7 +1404,7 @@ static inline bool is_filesystem_attributes_request(sal_uInt32 field_mask)
              osl_VolumeInfo_Mask_FileSystemCaseHandling));
 }
 
-//#############################################
+
 static oslFileError get_filesystem_attributes(
     const rtl::OUString& path, sal_uInt32 field_mask, oslVolumeInfo* pInfo)
 {
@@ -1458,7 +1458,7 @@ static oslFileError get_filesystem_attributes(
     return osl_File_E_None;
 }
 
-//#####################################################
+
 static bool path_get_parent(rtl::OUString& path)
 {
     OSL_PRECOND(path.lastIndexOf(SLASH) == -1, "Path must not have slashes");
@@ -1475,7 +1475,7 @@ static bool path_get_parent(rtl::OUString& path)
     return false;
 }
 
-//#####################################################
+
 static void path_travel_to_volume_root(const rtl::OUString& system_path, rtl::OUString& volume_root)
 {
     rtl::OUString sys_path(system_path);
@@ -1487,7 +1487,7 @@ static void path_travel_to_volume_root(const rtl::OUString& system_path, rtl::OU
     osl::systemPathEnsureSeparator(volume_root);
 }
 
-//#############################################
+
 oslFileError SAL_CALL osl_getVolumeInformation(
     rtl_uString *ustrURL, oslVolumeInfo *pInfo, sal_uInt32 uFieldMask )
 {
@@ -1522,7 +1522,7 @@ oslFileError SAL_CALL osl_getVolumeInformation(
     return osl_File_E_None;
 }
 
-//#####################################################
+
 static oslFileError SAL_CALL osl_getDriveInfo(
     oslDirectoryItem Item, oslFileStatus *pStatus, sal_uInt32 uFieldMask)
 {
@@ -1621,7 +1621,7 @@ static oslFileError SAL_CALL osl_getDriveInfo(
     return osl_File_E_None;
 }
 
-//#####################################################
+
 static oslFileError SAL_CALL osl_getServerInfo(
     oslDirectoryItem Item, oslFileStatus *pStatus, sal_uInt32 uFieldMask )
 {
@@ -1651,7 +1651,7 @@ static oslFileError SAL_CALL osl_getServerInfo(
     return osl_File_E_None;
 }
 
-//#############################################
+
 oslFileError SAL_CALL osl_getFileStatus(
     oslDirectoryItem Item,
     oslFileStatus *pStatus,
@@ -1767,11 +1767,11 @@ oslFileError SAL_CALL osl_getFileStatus(
     return osl_File_E_None;
 }
 
-//#####################################################
+
 // file attributes handling functions
-//#####################################################
 
-//#############################################
+
+
 oslFileError SAL_CALL osl_setFileAttributes(
     rtl_uString *ustrFileURL,
     sal_uInt64 uAttributes )
@@ -1812,7 +1812,7 @@ oslFileError SAL_CALL osl_setFileAttributes(
     return error;
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_setFileTime(
     rtl_uString *filePath,
     const TimeValue *aCreationTime,
diff --git a/sal/osl/w32/file_url.cxx b/sal/osl/w32/file_url.cxx
index 233b56e62bee..c9a039a45d25 100644
--- a/sal/osl/w32/file_url.cxx
+++ b/sal/osl/w32/file_url.cxx
@@ -40,14 +40,14 @@
 #define WSTR_LONG_PATH_PREFIX_UNC           L"\\\\?\\UNC\\"
 
 
-//##################################################################
+
 // FileURL functions
-//##################################################################
+
 
 extern "C" oslMutex g_CurrentDirectoryMutex; /* Initialized in dllentry.c */
 oslMutex g_CurrentDirectoryMutex = 0;
 
-//#####################################################
+
 static BOOL IsValidFilePathComponent(
     LPCTSTR lpComponent, LPCTSTR *lppComponentEnd, DWORD dwFlags)
 {
@@ -223,7 +223,7 @@ static BOOL IsValidFilePathComponent(
         return fValid;
 }
 
-//#####################################################
+
 #define CHARSET_SEPARATOR TEXT("\\/")
 
 DWORD IsValidFilePath(rtl_uString *path, LPCTSTR *lppError, DWORD dwFlags, rtl_uString **corrected)
@@ -384,7 +384,7 @@ DWORD IsValidFilePath(rtl_uString *path, LPCTSTR *lppError, DWORD dwFlags, rtl_u
         return fValid ? dwPathType : PATHTYPE_ERROR;
 }
 
-//#####################################################
+
 static sal_Int32 PathRemoveFileSpec(LPTSTR lpPath, LPTSTR lpFileName, sal_Int32 nFileBufLen )
 {
     sal_Int32 nRemoved = 0;
@@ -420,7 +420,7 @@ static sal_Int32 PathRemoveFileSpec(LPTSTR lpPath, LPTSTR lpFileName, sal_Int32
     return nRemoved;
 }
 
-//#####################################################
+
 // Undocumented in SHELL32.DLL ordinal 32
 static LPTSTR PathAddBackslash(LPTSTR lpPath, sal_Int32 nBufLen)
 {
@@ -440,7 +440,7 @@ static LPTSTR PathAddBackslash(LPTSTR lpPath, sal_Int32 nBufLen)
     return lpEndPath;
 }
 
-//#####################################################
+
 // Same as GetLongPathName but also 95/NT4
 static DWORD GetCaseCorrectPathNameEx(
     LPTSTR  lpszPath,   // path buffer to convert
@@ -526,7 +526,7 @@ static DWORD GetCaseCorrectPathNameEx(
         return _tcslen( lpszPath );
 }
 
-//#####################################################
+
 DWORD GetCaseCorrectPathName(
     LPCTSTR lpszShortPath,  // file name
     LPTSTR  lpszLongPath,   // path buffer
@@ -560,7 +560,7 @@ DWORD GetCaseCorrectPathName(
 }
 
 
-//#############################################
+
 static sal_Bool _osl_decodeURL( rtl_String* strUTF8, rtl_uString** pstrDecodedURL )
 {
     sal_Char        *pBuffer;
@@ -623,7 +623,7 @@ static sal_Bool _osl_decodeURL( rtl_String* strUTF8, rtl_uString** pstrDecodedUR
     return bValidEncoded;
 }
 
-//#############################################
+
 static void _osl_encodeURL( rtl_uString *strURL, rtl_String **pstrEncodedURL )
 {
     /* Encode non ascii characters within the URL */
@@ -692,7 +692,7 @@ static void _osl_encodeURL( rtl_uString *strURL, rtl_String **pstrEncodedURL )
     rtl_freeMemory( pszEncodedURL );
 }
 
-//#############################################
+
 
 oslFileError _osl_getSystemPathFromFileURL( rtl_uString *strURL, rtl_uString **pustrPath, sal_Bool bAllowRelative )
 {
@@ -831,7 +831,7 @@ oslFileError _osl_getSystemPathFromFileURL( rtl_uString *strURL, rtl_uString **p
     return nError;
 }
 
-//#############################################
+
 oslFileError _osl_getFileURLFromSystemPath( rtl_uString* strPath, rtl_uString** pstrURL )
 {
     oslFileError nError = osl_File_E_INVAL; /* Assume failure */
@@ -937,21 +937,21 @@ oslFileError _osl_getFileURLFromSystemPath( rtl_uString* strPath, rtl_uString**
     return nError;
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_getFileURLFromSystemPath(
     rtl_uString* ustrPath, rtl_uString** pustrURL )
 {
     return _osl_getFileURLFromSystemPath( ustrPath, pustrURL );
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_getSystemPathFromFileURL(
     rtl_uString *ustrURL, rtl_uString **pustrPath)
 {
     return _osl_getSystemPathFromFileURL( ustrURL, pustrPath, sal_True );
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_searchFileURL(
     rtl_uString *ustrFileName,
     rtl_uString *ustrSystemSearchPath,
@@ -1034,7 +1034,7 @@ oslFileError SAL_CALL osl_searchFileURL(
     return error;
 }
 
-//#####################################################
+
 
 oslFileError SAL_CALL osl_getAbsoluteFileURL( rtl_uString* ustrBaseURL, rtl_uString* ustrRelativeURL, rtl_uString** pustrAbsoluteURL )
 {
@@ -1115,7 +1115,7 @@ oslFileError SAL_CALL osl_getAbsoluteFileURL( rtl_uString* ustrBaseURL, rtl_uStr
     return  eError;
 }
 
-//#####################################################
+
 oslFileError SAL_CALL osl_getCanonicalName( rtl_uString *strRequested, rtl_uString **strValid )
 {
     rtl_uString_newFromString(strValid, strRequested);
diff --git a/sal/osl/w32/procimpl.cxx b/sal/osl/w32/procimpl.cxx
index 5d2e5a0b752c..2b83d0c128b8 100644
--- a/sal/osl/w32/procimpl.cxx
+++ b/sal/osl/w32/procimpl.cxx
@@ -46,10 +46,10 @@
 #include <string>
 #include <string.h>
 
-//#################################################
+
 extern "C" oslFileHandle SAL_CALL osl_createFileHandleFromOSHandle( HANDLE hFile, sal_uInt32 uFlags );
 
-//#################################################
+
 const sal_Unicode NAME_VALUE_SEPARATOR = TEXT('=');
 const sal_Char* SPACE = " ";
 const rtl::OUString ENV_COMSPEC ("COMSPEC");
@@ -57,14 +57,14 @@ const rtl::OUString QUOTE("\"");
 
 namespace /* private */
 {
-    //#################################################
+
     typedef std::list<rtl::OUString> string_container_t;
     typedef string_container_t::iterator string_container_iterator_t;
     typedef string_container_t::const_iterator string_container_const_iterator_t;
     typedef std::pair<string_container_iterator_t, string_container_iterator_t> iterator_pair_t;
     typedef std::vector<sal_Unicode> environment_container_t;
 
-    //#################################################
+
     /* Function object that compares two strings that are
        expected to be environment variables in the form
        "name=value". Only the 'name' part will be compared.
@@ -90,7 +90,7 @@ namespace /* private */
         }
     };
 
-    //#################################################
+
     /* Function object used by for_each algorithm to
        calculate the sum of the length of all strings
        in a string container. */
@@ -119,14 +119,14 @@ namespace /* private */
         size_t sum_;
     };
 
-    //#################################################
+
     inline size_t calc_sum_of_string_lengths(const string_container_t& string_cont)
     {
         return std::for_each(
             string_cont.begin(), string_cont.end(), sum_of_string_lengths());
     }
 
-    //#################################################
+
     void read_environment(/*out*/ string_container_t* environment)
     {
         // GetEnvironmentStrings returns a sorted list, Windows
@@ -142,7 +142,7 @@ namespace /* private */
         FreeEnvironmentStrings(env);
     }
 
-    //#################################################
+
     /* the environment list must be sorted, new values
     should either replace existing ones or should be
     added to the list, environment variables will
@@ -184,7 +184,7 @@ namespace /* private */
         return true;
     }
 
-    //#################################################
+
     /* Create a merged environment */
     bool setup_process_environment(
         rtl_uString* environment_vars[],
@@ -221,7 +221,7 @@ namespace /* private */
         return true;
     }
 
-    //##########################################################
+
     /*  In contrast to the Win32 API function CreatePipe with
         this function the caller is able to determine separately
         which handle of the pipe is inheritable. */
@@ -274,7 +274,7 @@ namespace /* private */
         return bRet;
     }
 
-    //#########################################################
+
     // Add a quote sign to the start and the end of a string
     // if not already present
     rtl::OUString quote_string(const rtl::OUString& string)
@@ -324,7 +324,7 @@ namespace /* private */
         }
         return ret;
     }
-    //##########################################################
+
     // Returns the system path of the executable which can either
     // be provided via the strImageName parameter or as first
     // element of the strArguments list.
@@ -358,7 +358,7 @@ namespace /* private */
         return exe_path;
     }
 
-    //##########################################################
+
     rtl::OUString get_file_extension(const rtl::OUString& file_name)
     {
         sal_Int32 index = file_name.lastIndexOf('.');
@@ -368,7 +368,7 @@ namespace /* private */
         return rtl::OUString();
     }
 
-    //##########################################################
+
     bool is_batch_file(const rtl::OUString& file_name)
     {
         rtl::OUString ext = get_file_extension(file_name);
@@ -377,7 +377,7 @@ namespace /* private */
                 ext.equalsIgnoreAsciiCase("btm"));
     }
 
-    //##########################################################
+
     rtl::OUString get_batch_processor()
     {
         rtl::OUString comspec;
@@ -395,7 +395,7 @@ namespace /* private */
 } // namespace private
 
 
-//#################################################
+
 oslProcessError SAL_CALL osl_executeProcess(
     rtl_uString *strImageName,
     rtl_uString *strArguments[],
@@ -421,7 +421,7 @@ oslProcessError SAL_CALL osl_executeProcess(
         NULL, NULL, NULL );
 }
 
-//#################################################
+
 oslProcessError SAL_CALL osl_executeProcess_WithRedirectedIO(
     rtl_uString *ustrImageName,
     rtl_uString *ustrArguments[],
diff --git a/sal/osl/w32/tempfile.cxx b/sal/osl/w32/tempfile.cxx
index d85410316b8f..422ad27ee98c 100644
--- a/sal/osl/w32/tempfile.cxx
+++ b/sal/osl/w32/tempfile.cxx
@@ -32,7 +32,7 @@
 #include <malloc.h>
 #include <tchar.h>
 
-//#####################################################
+
 // Allocate n number of t's on the stack return a pointer to it in p
 #ifdef __MINGW32__
 #define STACK_ALLOC(p, t, n) (p) = reinterpret_cast<t*>(_alloca((n)*sizeof(t)));
@@ -43,9 +43,9 @@
 
 extern "C" oslFileHandle SAL_CALL osl_createFileHandleFromOSHandle(HANDLE hFile, sal_uInt32 uFlags);
 
-//#####################################################
+
 // Temp file functions
-//#####################################################
+
 
 static oslFileError osl_setup_base_directory_impl_(
     rtl_uString*  pustrDirectoryURL,
@@ -75,7 +75,7 @@ static oslFileError osl_setup_base_directory_impl_(
     return error;
 }
 
-//#####################################################
+
 static oslFileError osl_setup_createTempFile_impl_(
     rtl_uString*   pustrDirectoryURL,
     oslFileHandle* pHandle,
@@ -102,7 +102,7 @@ static oslFileError osl_setup_createTempFile_impl_(
     return osl_error;
 }
 
-//#####################################################
+
 static oslFileError osl_win32_GetTempFileName_impl_(
     rtl_uString* base_directory, LPWSTR temp_file_name)
 {
@@ -120,7 +120,7 @@ static oslFileError osl_win32_GetTempFileName_impl_(
     return osl_error;
 }
 
-//#####################################################
+
 static sal_Bool osl_win32_CreateFile_impl_(
     LPCWSTR file_name, sal_Bool b_delete_on_close, oslFileHandle* p_handle)
 {
@@ -148,7 +148,7 @@ static sal_Bool osl_win32_CreateFile_impl_(
     return (sal_Bool)IsValidHandle(hFile);
 }
 
-//#############################################
+
 static oslFileError osl_createTempFile_impl_(
     rtl_uString*   base_directory,
     LPWSTR         tmp_name,
@@ -181,7 +181,7 @@ static oslFileError osl_createTempFile_impl_(
     return osl_error;
 }
 
-//#############################################
+
 oslFileError SAL_CALL osl_createTempFile(
     rtl_uString*   pustrDirectoryURL,
     oslFileHandle* pHandle,
@@ -225,7 +225,7 @@ oslFileError SAL_CALL osl_createTempFile(
     return osl_error;
 }
 
-//#############################################
+
 oslFileError SAL_CALL osl_getTempDirURL(rtl_uString** pustrTempDir)
 {
     ::osl::LongPathBuffer< sal_Unicode > aBuffer( MAX_LONG_PATH );
diff --git a/sal/osl/w32/time.c b/sal/osl/w32/time.c
index 52fe8ac09b87..4e66aaeceb6f 100644
--- a/sal/osl/w32/time.c
+++ b/sal/osl/w32/time.c
@@ -27,9 +27,9 @@ extern sal_Bool TimeValueToFileTime(const TimeValue *cpTimeVal, FILETIME *pFTime
 
 extern BOOL FileTimeToTimeValue( const FILETIME *cpFTime, TimeValue *pTimeVal );
 
-//--------------------------------------------------
+
 // osl_getSystemTime
-//--------------------------------------------------
+
 
 sal_Bool SAL_CALL osl_getSystemTime(TimeValue* pTimeVal)
 {
@@ -61,9 +61,9 @@ sal_Bool SAL_CALL osl_getSystemTime(TimeValue* pTimeVal)
     return (sal_True);
 }
 
-//--------------------------------------------------
+
 // osl_getDateTimeFromTimeValue
-//--------------------------------------------------
+
 
 sal_Bool SAL_CALL osl_getDateTimeFromTimeValue( const TimeValue* pTimeVal, oslDateTime* pDateTime )
 {
@@ -91,9 +91,9 @@ 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 )
 {
@@ -122,9 +122,9 @@ sal_Bool SAL_CALL osl_getTimeValueFromDateTime( const oslDateTime* pDateTime, Ti
 }
 
 
-//--------------------------------------------------
+
 // osl_getLocalTimeFromSystemTime
-//--------------------------------------------------
+
 
 sal_Bool SAL_CALL osl_getLocalTimeFromSystemTime( const TimeValue* pSystemTimeVal, TimeValue* pLocalTimeVal )
 {
@@ -153,9 +153,9 @@ 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 )
 {