Remove unneccessary comments

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

15 files changed, 415 insertions, 415 deletions

diff --git a/connectivity/source/drivers/mork/MCatalog.cxx b/connectivity/source/drivers/mork/MCatalog.cxx
index 663ee08d2267..1426378f48dc 100644
--- a/connectivity/source/drivers/mork/MCatalog.cxx
+++ b/connectivity/source/drivers/mork/MCatalog.cxx
@@ -24,7 +24,7 @@
 #include <com/sun/star/sdbc/XResultSet.hpp>
 #include <cppuhelper/interfacecontainer.h>
 
-// -------------------------------------------------------------------------
+
 using namespace connectivity::mork;
 using namespace ::com::sun::star::uno;
 using namespace ::com::sun::star::beans;
@@ -34,7 +34,7 @@ using namespace ::com::sun::star::container;
 using namespace ::com::sun::star::lang;
 using namespace ::cppu;
 
-// -------------------------------------------------------------------------
+
 OCatalog::OCatalog(OConnection* _pCon) : connectivity::sdbcx::OCatalog(_pCon)
                 ,m_pConnection(_pCon)
                 ,m_xMetaData(m_pConnection->getMetaData(  ))
@@ -46,7 +46,7 @@ OCatalog::OCatalog(OConnection* _pCon) : connectivity::sdbcx::OCatalog(_pCon)
 //  refreshUsers();
 //  osl_atomic_decrement( &m_refCount );
 }
-// -------------------------------------------------------------------------
+
 void OCatalog::refreshTables()
 {
     TStringVector aVector;
@@ -70,19 +70,19 @@ void OCatalog::refreshTables()
     else
         m_pTables = new OTables(m_xMetaData,*this,m_aMutex,aVector);
 }
-// -------------------------------------------------------------------------
+
 void OCatalog::refreshViews()
 {
 }
-// -------------------------------------------------------------------------
+
 void OCatalog::refreshGroups()
 {
 }
-// -------------------------------------------------------------------------
+
 void OCatalog::refreshUsers()
 {
 }
-// -----------------------------------------------------------------------------
+
 
 // XTablesSupplier
 Reference< XNameAccess > SAL_CALL OCatalog::getTables(  ) throw(RuntimeException)
diff --git a/connectivity/source/drivers/mork/MColumnAlias.cxx b/connectivity/source/drivers/mork/MColumnAlias.cxx
index 96af40bf706b..0ad8a3dc8685 100644
--- a/connectivity/source/drivers/mork/MColumnAlias.cxx
+++ b/connectivity/source/drivers/mork/MColumnAlias.cxx
@@ -37,7 +37,7 @@ using namespace ::com::sun::star::lang;
 using namespace ::com::sun::star::beans;
 using namespace ::com::sun::star::container;
 
-//------------------------------------------------------------------------------
+
 OColumnAlias::OColumnAlias( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rxORB )
 {
     static const sal_Char* s_pProgrammaticNames[] =
@@ -87,7 +87,7 @@ OColumnAlias::OColumnAlias( const ::com::sun::star::uno::Reference< ::com::sun::
     initialize( _rxORB );
 }
 
-//------------------------------------------------------------------------------
+
 void OColumnAlias::initialize( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rxORB )
 {
     Reference< XNameAccess > xAliasesNode(
@@ -125,7 +125,7 @@ void OColumnAlias::initialize( const ::com::sun::star::uno::Reference< ::com::su
     }
 }
 
-//------------------------------------------------------------------
+
 OString OColumnAlias::getProgrammaticNameOrFallbackToUTF8Alias( const OUString& _rAlias ) const
 {
     AliasMap::const_iterator pos = m_aAliasMap.find( _rAlias );
diff --git a/connectivity/source/drivers/mork/MColumns.cxx b/connectivity/source/drivers/mork/MColumns.cxx
index 009ed6b998ad..57851ee70f70 100644
--- a/connectivity/source/drivers/mork/MColumns.cxx
+++ b/connectivity/source/drivers/mork/MColumns.cxx
@@ -82,12 +82,12 @@ sdbcx::ObjectType OColumns::createObject(const OUString& _rName)
     return xRet;
 }
 
-// -------------------------------------------------------------------------
+
 void OColumns::impl_refresh() throw(RuntimeException)
 {
     m_pTable->refreshColumns();
 }
-// -----------------------------------------------------------------------------
+
 
 
 
diff --git a/connectivity/source/drivers/mork/MConnection.cxx b/connectivity/source/drivers/mork/MConnection.cxx
index 78956371372f..71b44a115648 100644
--- a/connectivity/source/drivers/mork/MConnection.cxx
+++ b/connectivity/source/drivers/mork/MConnection.cxx
@@ -32,19 +32,19 @@
 
 using namespace dbtools;
 
-//------------------------------------------------------------------------------
+
 using namespace com::sun::star::uno;
 using namespace com::sun::star::lang;
 using namespace com::sun::star::beans;
 using namespace com::sun::star::sdbc;
 using namespace com::sun::star::sdbcx;
-// --------------------------------------------------------------------------------
+
 
 namespace connectivity { namespace mork {
 
 static const int defaultScope = 0x80;
 
-// -----------------------------------------------------------------------------
+
 
 OConnection::OConnection(MorkDriver* _pDriver)
     :OSubComponent<OConnection, OConnection_BASE>((::cppu::OWeakObject*)_pDriver, this)
@@ -56,7 +56,7 @@ OConnection::OConnection(MorkDriver* _pDriver)
     m_pBook = new MorkParser();
     m_pHistory = new MorkParser();
 }
-//-----------------------------------------------------------------------------
+
 OConnection::~OConnection()
 {
     acquire();
@@ -68,13 +68,13 @@ OConnection::~OConnection()
     delete m_pBook;
     delete m_pHistory;
 }
-//-----------------------------------------------------------------------------
+
 void SAL_CALL OConnection::release() throw()
 {
     relase_ChildImpl();
 }
-// -----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
+
+
 void OConnection::construct(const OUString& url,const Sequence< PropertyValue >& info)  throw(SQLException)
 {
     (void) info; // avoid warnings
@@ -173,10 +173,10 @@ void OConnection::construct(const OUString& url,const Sequence< PropertyValue >&
 }
 
 // XServiceInfo
-// --------------------------------------------------------------------------------
+
 IMPLEMENT_SERVICE_INFO(OConnection, "com.sun.star.sdbc.drivers.mork.OConnection", "com.sun.star.sdbc.Connection")
 
-// --------------------------------------------------------------------------------
+
 Reference< XStatement > SAL_CALL OConnection::createStatement(  ) throw(SQLException, RuntimeException)
 {
     SAL_INFO("connectivity.mork", "=> OConnection::createStatement()" );
@@ -190,7 +190,7 @@ Reference< XStatement > SAL_CALL OConnection::createStatement(  ) throw(SQLExcep
     m_aStatements.push_back(WeakReferenceHelper(xReturn));
     return xReturn;
 }
-// --------------------------------------------------------------------------------
+
 Reference< XPreparedStatement > SAL_CALL OConnection::prepareStatement( const OUString& _sSql ) throw(SQLException, RuntimeException)
 {
     SAL_INFO("connectivity.mork", "=> OConnection::prepareStatement()" );
@@ -210,7 +210,7 @@ Reference< XPreparedStatement > SAL_CALL OConnection::prepareStatement( const OU
     m_aStatements.push_back(WeakReferenceHelper(xReturn));
     return xReturn;
 }
-// --------------------------------------------------------------------------------
+
 Reference< XPreparedStatement > SAL_CALL OConnection::prepareCall( const OUString& _sSql ) throw(SQLException, RuntimeException)
 {
     SAL_INFO("connectivity.mork", "=> OConnection::prepareCall()" );
@@ -220,7 +220,7 @@ Reference< XPreparedStatement > SAL_CALL OConnection::prepareCall( const OUStrin
     SAL_INFO("connectivity.mork", "OConnection::prepareCall( " << _sSql << " )");
     return NULL;
 }
-// --------------------------------------------------------------------------------
+
 OUString SAL_CALL OConnection::nativeSQL( const OUString& _sSql ) throw(SQLException, RuntimeException)
 {
     SAL_INFO("connectivity.mork", "=> OConnection::nativeSQL()" );
@@ -232,12 +232,12 @@ OUString SAL_CALL OConnection::nativeSQL( const OUString& _sSql ) throw(SQLExcep
 
     return _sSql;
 }
-// --------------------------------------------------------------------------------
+
 void SAL_CALL OConnection::setAutoCommit( sal_Bool /*autoCommit*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XConnection::setAutoCommit", *this );
 }
-// --------------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OConnection::getAutoCommit(  ) throw(SQLException, RuntimeException)
 {
     // you have to distinguish which if you are in autocommit mode or not
@@ -245,17 +245,17 @@ sal_Bool SAL_CALL OConnection::getAutoCommit(  ) throw(SQLException, RuntimeExce
 
     return sal_True;
 }
-// --------------------------------------------------------------------------------
+
 void SAL_CALL OConnection::commit(  ) throw(SQLException, RuntimeException)
 {
     // when you database does support transactions you should commit here
 }
-// --------------------------------------------------------------------------------
+
 void SAL_CALL OConnection::rollback(  ) throw(SQLException, RuntimeException)
 {
     // same as commit but for the other case
 }
-// --------------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OConnection::isClosed(  ) throw(SQLException, RuntimeException)
 {
     ::osl::MutexGuard aGuard( m_aMutex );
@@ -263,7 +263,7 @@ sal_Bool SAL_CALL OConnection::isClosed(  ) throw(SQLException, RuntimeException
     // just simple -> we are close when we are disposed that means someone called dispose(); (XComponent)
     return OConnection_BASE::rBHelper.bDisposed;
 }
-// --------------------------------------------------------------------------------
+
 Reference< XDatabaseMetaData > SAL_CALL OConnection::getMetaData(  ) throw(SQLException, RuntimeException)
 {
     SAL_INFO("connectivity.mork", "=> OConnection::getMetaData()" );
@@ -282,50 +282,50 @@ Reference< XDatabaseMetaData > SAL_CALL OConnection::getMetaData(  ) throw(SQLEx
 
     return xMetaData;
 }
-// --------------------------------------------------------------------------------
+
 void SAL_CALL OConnection::setReadOnly( sal_Bool /*readOnly*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XConnection::setReadOnly", *this );
 }
-// --------------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OConnection::isReadOnly(  ) throw(SQLException, RuntimeException)
 {
     // return if your connection to readonly
     return sal_False;
 }
-// --------------------------------------------------------------------------------
+
 void SAL_CALL OConnection::setCatalog( const OUString& /*catalog*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XConnection::setCatalog", *this );
 }
-// --------------------------------------------------------------------------------
+
 OUString SAL_CALL OConnection::getCatalog(  ) throw(SQLException, RuntimeException)
 {
     return OUString();
 }
-// --------------------------------------------------------------------------------
+
 void SAL_CALL OConnection::setTransactionIsolation( sal_Int32 /*level*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XConnection::setTransactionIsolation", *this );
 }
-// --------------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL OConnection::getTransactionIsolation(  ) throw(SQLException, RuntimeException)
 {
     // please have a look at @see com.sun.star.sdbc.TransactionIsolation
     return TransactionIsolation::NONE;
 }
-// --------------------------------------------------------------------------------
+
 Reference< ::com::sun::star::container::XNameAccess > SAL_CALL OConnection::getTypeMap(  ) throw(SQLException, RuntimeException)
 {
     // if your driver has special database types you can return it here
     return NULL;
 }
-// --------------------------------------------------------------------------------
+
 void SAL_CALL OConnection::setTypeMap( const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XConnection::setTypeMap", *this );
 }
-// --------------------------------------------------------------------------------
+
 // XCloseable
 void SAL_CALL OConnection::close(  ) throw(SQLException, RuntimeException)
 {
@@ -337,26 +337,26 @@ void SAL_CALL OConnection::close(  ) throw(SQLException, RuntimeException)
     }
     dispose();
 }
-// --------------------------------------------------------------------------------
+
 // XWarningsSupplier
 Any SAL_CALL OConnection::getWarnings(  ) throw(SQLException, RuntimeException)
 {
     // when you collected some warnings -> return it
     return Any();
 }
-// --------------------------------------------------------------------------------
+
 void SAL_CALL OConnection::clearWarnings(  ) throw(SQLException, RuntimeException)
 {
     // you should clear your collected warnings here
 }
-//------------------------------------------------------------------------------
+
 void OConnection::disposing()
 {
     // we noticed that we should be destroied in near future so we have to dispose our statements
     ::osl::MutexGuard aGuard(m_aMutex);
     dispose_ChildImpl();
 }
-// -----------------------------------------------------------------------------
+
 
 Reference< XTablesSupplier > SAL_CALL OConnection::createCatalog()
 {
@@ -372,9 +372,9 @@ Reference< XTablesSupplier > SAL_CALL OConnection::createCatalog()
     OSL_TRACE( "\tOUT OConnection::createCatalog()" );
     return xTab;
 }
-// -----------------------------------------------------------------------------
 
-// -----------------------------------------------------------------------------
+
+
 void OConnection::throwSQLException( const ErrorDescriptor& _rError, const Reference< XInterface >& _rxContext )
 {
     if ( _rError.getResId() != 0 )
@@ -411,7 +411,7 @@ void OConnection::throwSQLException( const ErrorDescriptor& _rError, const Refer
     throwGenericSQLException( STR_UNSPECIFIED_ERROR, _rxContext );
 }
 
-// -----------------------------------------------------------------------------
+
 void OConnection::throwSQLException( const sal_uInt16 _nErrorResourceId, const Reference< XInterface >& _rxContext )
 {
     ErrorDescriptor aError;
diff --git a/connectivity/source/drivers/mork/MDatabaseMetaData.cxx b/connectivity/source/drivers/mork/MDatabaseMetaData.cxx
index a850bdec26dd..94be41197400 100644
--- a/connectivity/source/drivers/mork/MDatabaseMetaData.cxx
+++ b/connectivity/source/drivers/mork/MDatabaseMetaData.cxx
@@ -52,13 +52,13 @@ ODatabaseMetaData::ODatabaseMetaData(OConnection* _pCon)
     OSL_ENSURE(m_pConnection,"ODatabaseMetaData::ODatabaseMetaData: No connection set!");
     m_pMetaDataHelper = new MDatabaseMetaDataHelper();
 }
-// -------------------------------------------------------------------------
+
 ODatabaseMetaData::~ODatabaseMetaData()
 {
     delete m_pMetaDataHelper;
 }
 
-// -------------------------------------------------------------------------
+
 ODatabaseMetaDataResultSet::ORows& SAL_CALL ODatabaseMetaData::getColumnRows(
         const OUString& tableNamePattern,
         const OUString& columnNamePattern ) throw(SQLException)
@@ -147,317 +147,317 @@ ODatabaseMetaDataResultSet::ORows& SAL_CALL ODatabaseMetaData::getColumnRows(
     }
     return( aRows );
 }
-// -------------------------------------------------------------------------
+
 OUString ODatabaseMetaData::impl_getCatalogSeparator_throw(  )
 {
     return OUString();
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxBinaryLiteralLength(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 65535; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxRowSize(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxCatalogNameLength(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxCharLiteralLength(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 254; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnNameLength(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 20; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnsInIndex(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxCursorNameLength(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxConnections(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnsInTable(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 ODatabaseMetaData::impl_getMaxStatements_throw(  )
 {
     return 0;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxTableNameLength(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 ODatabaseMetaData::impl_getMaxTablesInSelect_throw(  )
 {
     // We only support a single table
     return 1;
 }
-// -------------------------------------------------------------------------
-// -------------------------------------------------------------------------
+
+
 sal_Bool SAL_CALL ODatabaseMetaData::doesMaxRowSizeIncludeBlobs(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::storesLowerCaseQuotedIdentifiers(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::storesLowerCaseIdentifiers(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool ODatabaseMetaData::impl_storesMixedCaseQuotedIdentifiers_throw(  )
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::storesMixedCaseIdentifiers(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::storesUpperCaseQuotedIdentifiers(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::storesUpperCaseIdentifiers(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool ODatabaseMetaData::impl_supportsAlterTableWithAddColumn_throw(  )
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool ODatabaseMetaData::impl_supportsAlterTableWithDropColumn_throw(  )
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxIndexLength(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsNonNullableColumns(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getCatalogTerm(  ) throw(SQLException, RuntimeException)
 {
     OUString aVal;
     return aVal;
 }
-// -------------------------------------------------------------------------
+
 OUString ODatabaseMetaData::impl_getIdentifierQuoteString_throw(  )
 {
     // normally this is "
     return OUString( "\"");
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getExtraNameCharacters(  ) throw(SQLException, RuntimeException)
 {
     OUString aVal;
     return aVal;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsDifferentTableCorrelationNames(  ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool ODatabaseMetaData::impl_isCatalogAtStart_throw(  )
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::dataDefinitionIgnoredInTransactions(  ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::dataDefinitionCausesTransactionCommit(  ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsDataManipulationTransactionsOnly(  ) throw(SQLException, RuntimeException)
 {
     //We support create table
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsDataDefinitionAndDataManipulationTransactions(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsPositionedDelete(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsPositionedUpdate(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsOpenStatementsAcrossRollback(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsOpenStatementsAcrossCommit(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsOpenCursorsAcrossCommit(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsOpenCursorsAcrossRollback(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsTransactionIsolationLevel( sal_Int32 /*level*/ ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool ODatabaseMetaData::impl_supportsSchemasInDataManipulation_throw(  )
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsANSI92FullSQL(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsANSI92EntryLevelSQL(  ) throw(SQLException, RuntimeException)
 {
     return sal_True; // should be supported at least
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsIntegrityEnhancementFacility(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsSchemasInIndexDefinitions(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool ODatabaseMetaData::impl_supportsSchemasInTableDefinitions_throw(  )
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool ODatabaseMetaData::impl_supportsCatalogsInTableDefinitions_throw(  )
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsCatalogsInIndexDefinitions(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool ODatabaseMetaData::impl_supportsCatalogsInDataManipulation_throw(  )
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsOuterJoins(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxStatementLength(  ) throw(SQLException, RuntimeException)
 {
     return 0;// 0 means no limit
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxProcedureNameLength(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxSchemaNameLength(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsTransactions(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::allProceduresAreCallable(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsStoredProcedures(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsSelectForUpdate(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::allTablesAreSelectable(  ) throw(SQLException, RuntimeException)
 {
     // We allow you to select from any table.
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::isReadOnly(  ) throw(SQLException, RuntimeException)
 {
     //we support insert/update/delete now
@@ -465,384 +465,384 @@ sal_Bool SAL_CALL ODatabaseMetaData::isReadOnly(  ) throw(SQLException, RuntimeE
     //entry to the popup menu. We should avoid them.
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::usesLocalFiles(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::usesLocalFilePerTable(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsTypeConversion(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::nullPlusNonNullIsNull(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsColumnAliasing(  ) throw(SQLException, RuntimeException)
 {
     // Support added for this.
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsTableCorrelationNames(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsConvert( sal_Int32 /*fromType*/, sal_Int32 /*toType*/ ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsExpressionsInOrderBy(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsGroupBy(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsGroupByBeyondSelect(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsGroupByUnrelated(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsMultipleTransactions(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsMultipleResultSets(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsLikeEscapeClause(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsOrderByUnrelated(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsUnion(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsUnionAll(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsMixedCaseIdentifiers(  ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool ODatabaseMetaData::impl_supportsMixedCaseQuotedIdentifiers_throw(  )
 {
     // Any case may be used
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::nullsAreSortedAtEnd(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::nullsAreSortedAtStart(  ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::nullsAreSortedHigh(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::nullsAreSortedLow(  ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsSchemasInProcedureCalls(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsSchemasInPrivilegeDefinitions(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsCatalogsInProcedureCalls(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsCatalogsInPrivilegeDefinitions(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsCorrelatedSubqueries(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsSubqueriesInComparisons(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsSubqueriesInExists(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsSubqueriesInIns(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsSubqueriesInQuantifieds(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsANSI92IntermediateSQL(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getURL(  ) throw(SQLException, RuntimeException)
 {
     ::osl::MutexGuard aGuard( m_aMutex );
 
     return m_pConnection->getURL();
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getUserName(  ) throw(SQLException, RuntimeException)
 {
     OUString aValue;
     return aValue;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getDriverName(  ) throw(SQLException, RuntimeException)
 {
     OUString aValue;
     return aValue;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getDriverVersion() throw(SQLException, RuntimeException)
 {
     OUString aValue = OUString::number(1);
     return aValue;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getDatabaseProductVersion(  ) throw(SQLException, RuntimeException)
 {
     OUString aValue = OUString::number(0);
     return aValue;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getDatabaseProductName(  ) throw(SQLException, RuntimeException)
 {
     OUString aValue;
     return aValue;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getProcedureTerm(  ) throw(SQLException, RuntimeException)
 {
     OUString aValue;
     return aValue;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getSchemaTerm(  ) throw(SQLException, RuntimeException)
 {
     OUString aValue;
     return aValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getDriverMajorVersion(  ) throw(RuntimeException)
 {
     return 1;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getDefaultTransactionIsolation(  ) throw(SQLException, RuntimeException)
 {
     return TransactionIsolation::NONE;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getDriverMinorVersion(  ) throw(RuntimeException)
 {
     return 0;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getSQLKeywords(  ) throw(SQLException, RuntimeException)
 {
     OUString aValue;
     return aValue;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getSearchStringEscape(  ) throw(SQLException, RuntimeException)
 {
     OUString aValue;
     return aValue;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getStringFunctions(  ) throw(SQLException, RuntimeException)
 {
     return OUString();
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getTimeDateFunctions(  ) throw(SQLException, RuntimeException)
 {
     return OUString();
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getSystemFunctions(  ) throw(SQLException, RuntimeException)
 {
     return OUString();
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL ODatabaseMetaData::getNumericFunctions(  ) throw(SQLException, RuntimeException)
 {
     return OUString();
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsExtendedSQLGrammar(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsCoreSQLGrammar(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsMinimumSQLGrammar(  ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsFullOuterJoins(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsLimitedOuterJoins(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnsInGroupBy(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnsInOrderBy(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnsInSelect(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL ODatabaseMetaData::getMaxUserNameLength(  ) throw(SQLException, RuntimeException)
 {
     sal_Int32 nValue = 0; // 0 means no limit
     return nValue;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsResultSetType( sal_Int32 /*setType*/ ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsResultSetConcurrency( sal_Int32 /*setType*/, sal_Int32 /*concurrency*/ ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::ownUpdatesAreVisible( sal_Int32 /*setType*/ ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::ownDeletesAreVisible( sal_Int32 /*setType*/ ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::ownInsertsAreVisible( sal_Int32 /*setType*/ ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::othersUpdatesAreVisible( sal_Int32 /*setType*/ ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::othersDeletesAreVisible( sal_Int32 /*setType*/ ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::othersInsertsAreVisible( sal_Int32 /*setType*/ ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::updatesAreDetected( sal_Int32 /*setType*/ ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::deletesAreDetected( sal_Int32 /*setType*/ ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::insertsAreDetected( sal_Int32 /*setType*/ ) throw(SQLException, RuntimeException)
 {
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL ODatabaseMetaData::supportsBatchUpdates(  ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 // here follow all methods which return a resultset
 // the first methods is an example implementation how to use this resultset
 // of course you could implement it on your and you should do this because
 // the general way is more memory expensive
-// -------------------------------------------------------------------------
+
 Reference< XResultSet > SAL_CALL ODatabaseMetaData::getTableTypes(  ) throw(SQLException, RuntimeException)
 {
     // there exists no possibility to get table types so we have to check
@@ -876,7 +876,7 @@ Reference< XResultSet > SAL_CALL ODatabaseMetaData::getTableTypes(  ) throw(SQLE
     pResult->setRows(aRows);
     return xRef;
 }
-// -------------------------------------------------------------------------
+
 Reference< XResultSet > ODatabaseMetaData::impl_getTypeInfo_throw(  )
 {
     // this returns an empty resultset where the column-names are already set
@@ -916,7 +916,7 @@ Reference< XResultSet > ODatabaseMetaData::impl_getTypeInfo_throw(  )
     pResultSet->setRows(aRows);
     return xResultSet;
 }
-// -------------------------------------------------------------------------
+
 Reference< XResultSet > SAL_CALL ODatabaseMetaData::getColumns(
     const Any& /*catalog*/, const OUString& /*schemaPattern*/, const OUString& tableNamePattern,
     const OUString& columnNamePattern ) throw(SQLException, RuntimeException)
@@ -928,7 +928,7 @@ Reference< XResultSet > SAL_CALL ODatabaseMetaData::getColumns(
     pResultSet->setRows( getColumnRows( tableNamePattern, columnNamePattern ));
     return xResultSet;
 }
-// -------------------------------------------------------------------------
+
 Reference< XResultSet > SAL_CALL ODatabaseMetaData::getTables(
     const Any& /*catalog*/, const OUString& /*schemaPattern*/,
     const OUString& tableNamePattern, const Sequence< OUString >& /*types*/ ) throw(SQLException, RuntimeException)
@@ -954,7 +954,7 @@ Reference< XResultSet > SAL_CALL ODatabaseMetaData::getTables(
 
     return xResultSet;
 }
-// -------------------------------------------------------------------------
+
 Reference< XResultSet > SAL_CALL ODatabaseMetaData::getTablePrivileges(
     const Any& /*catalog*/, const OUString& /*schemaPattern*/, const OUString& tableNamePattern ) throw(SQLException, RuntimeException)
 {
@@ -1013,11 +1013,11 @@ Reference< XResultSet > SAL_CALL ODatabaseMetaData::getTablePrivileges(
     pResult->setRows(aRows);
     return xRef;
 }
-// -------------------------------------------------------------------------
+
 Reference< XResultSet > SAL_CALL ODatabaseMetaData::getUDTs( const Any& /*catalog*/, const OUString& /*schemaPattern*/, const OUString& /*typeNamePattern*/, const Sequence< sal_Int32 >& /*types*/ ) throw(SQLException, RuntimeException)
 {
     return NULL;
 }
-// -----------------------------------------------------------------------------
+
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MDatabaseMetaDataHelper.cxx b/connectivity/source/drivers/mork/MDatabaseMetaDataHelper.cxx
index 9502919bc569..4aba2596cfd0 100644
--- a/connectivity/source/drivers/mork/MDatabaseMetaDataHelper.cxx
+++ b/connectivity/source/drivers/mork/MDatabaseMetaDataHelper.cxx
@@ -36,13 +36,13 @@ static ::osl::Mutex m_aMetaMutex;
 using namespace connectivity;
 using namespace connectivity::mork;
 
-// -------------------------------------------------------------------------
+
 MDatabaseMetaDataHelper::MDatabaseMetaDataHelper()
 {
     SAL_INFO("connectivity.mork", "=> MDatabaseMetaDataHelper::MDatabaseMetaDataHelper()" );
 }
 
-// -------------------------------------------------------------------------
+
 MDatabaseMetaDataHelper::~MDatabaseMetaDataHelper()
 {
 }
diff --git a/connectivity/source/drivers/mork/MDriver.cxx b/connectivity/source/drivers/mork/MDriver.cxx
index 33a22aa90b6b..11619f08487b 100644
--- a/connectivity/source/drivers/mork/MDriver.cxx
+++ b/connectivity/source/drivers/mork/MDriver.cxx
@@ -38,13 +38,13 @@ MorkDriver::MorkDriver(css::uno::Reference< css::uno::XComponentContext > const
 }
 
 // static ServiceInfo
-//------------------------------------------------------------------------------
+
 OUString MorkDriver::getImplementationName_Static(  ) throw(css::uno::RuntimeException)
 {
     return OUString(MORK_DRIVER_IMPL_NAME);
 }
 
-//------------------------------------------------------------------------------
+
 css::uno::Sequence< OUString > MorkDriver::getSupportedServiceNames_Static(  ) throw (css::uno::RuntimeException)
 {
     css::uno::Sequence< OUString > aSNS(1);
diff --git a/connectivity/source/drivers/mork/MNSFolders.cxx b/connectivity/source/drivers/mork/MNSFolders.cxx
index 71a01493d659..5237a9304f23 100644
--- a/connectivity/source/drivers/mork/MNSFolders.cxx
+++ b/connectivity/source/drivers/mork/MNSFolders.cxx
@@ -41,7 +41,7 @@ using namespace ::com::sun::star::mozilla;
 
 namespace
 {
-    // -------------------------------------------------------------------
+
     static OUString lcl_getUserDataDirectory()
     {
         ::osl::Security   aSecurity;
@@ -59,7 +59,7 @@ namespace
         return aConfigPath + "/";
     }
 
-    // -------------------------------------------------------------------
+
     const size_t NB_PRODUCTS = 3;
     const size_t NB_CANDIDATES = 4;
 
@@ -87,7 +87,7 @@ namespace
         "MOZILLA_THUNDERBIRD_PROFILE_ROOT",
     };
 
-    // -------------------------------------------------------------------
+
     static OUString lcl_guessProfileRoot( MozillaProductType _product )
     {
         size_t productIndex = _product - 1;
@@ -144,7 +144,7 @@ namespace
     }
 }
 
-// -----------------------------------------------------------------------
+
 OUString getRegistryDir(MozillaProductType product)
 {
     if (product == MozillaProductType_Default)
diff --git a/connectivity/source/drivers/mork/MPreparedStatement.cxx b/connectivity/source/drivers/mork/MPreparedStatement.cxx
index 00bf3ca1ec70..3cbc45d904e2 100644
--- a/connectivity/source/drivers/mork/MPreparedStatement.cxx
+++ b/connectivity/source/drivers/mork/MPreparedStatement.cxx
@@ -51,17 +51,17 @@ OPreparedStatement::OPreparedStatement( OConnection* _pConnection,const OUString
     ,m_pResultSet()
 {
 }
-// -----------------------------------------------------------------------------
+
 OPreparedStatement::~OPreparedStatement()
 {
 }
-// -----------------------------------------------------------------------------
+
 void OPreparedStatement::lateInit()
 {
     if ( eSelect != parseSql( m_sSqlStatement ) )
         throw SQLException();
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OPreparedStatement::disposing()
 {
     ::osl::MutexGuard aGuard(m_aMutex);
@@ -76,7 +76,7 @@ void SAL_CALL OPreparedStatement::disposing()
     }
     m_xParamColumns = NULL;
 }
-// -----------------------------------------------------------------------------
+
 
 OCommonStatement::StatementType OPreparedStatement::parseSql( const OUString& sql , sal_Bool bAdjusted )
     throw ( ::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException )
@@ -98,7 +98,7 @@ OCommonStatement::StatementType OPreparedStatement::parseSql( const OUString& sq
     return eStatementType;
 }
 
-// -----------------------------------------------------------------------------
+
 void OPreparedStatement::initializeResultSet( OResultSet* _pResult )
 {
     OCommonStatement::initializeResultSet( _pResult );
@@ -106,14 +106,14 @@ void OPreparedStatement::initializeResultSet( OResultSet* _pResult )
     _pResult->setParameterRow( m_aParameterRow );
 }
 
-// -----------------------------------------------------------------------------
+
 void OPreparedStatement::clearCachedResultSet()
 {
     OCommonStatement::clearCachedResultSet();
     m_pResultSet.clear();
     m_xMetaData.clear();
 }
-// -----------------------------------------------------------------------------
+
 void OPreparedStatement::cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult )
 {
     OCommonStatement::cacheResultSet( _pResult );
@@ -121,17 +121,17 @@ void OPreparedStatement::cacheResultSet( const ::rtl::Reference< OResultSet >& _
     m_pResultSet = _pResult;
 }
 
-// -----------------------------------------------------------------------------
+
 void SAL_CALL OPreparedStatement::acquire() throw()
 {
     OCommonStatement::acquire();
 }
-// -----------------------------------------------------------------------------
+
 void SAL_CALL OPreparedStatement::release() throw()
 {
     OCommonStatement::release();
 }
-// -----------------------------------------------------------------------------
+
 Any SAL_CALL OPreparedStatement::queryInterface( const Type & rType ) throw(RuntimeException)
 {
     Any aRet = OCommonStatement::queryInterface(rType);
@@ -139,12 +139,12 @@ Any SAL_CALL OPreparedStatement::queryInterface( const Type & rType ) throw(Runt
         aRet = OPreparedStatement_BASE::queryInterface(rType);
     return aRet;
 }
-// -------------------------------------------------------------------------
+
 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL OPreparedStatement::getTypes(  ) throw(::com::sun::star::uno::RuntimeException)
 {
     return ::comphelper::concatSequences(OPreparedStatement_BASE::getTypes(),OCommonStatement::getTypes());
 }
-// -------------------------------------------------------------------------
+
 
 Reference< XResultSetMetaData > SAL_CALL OPreparedStatement::getMetaData(  ) throw(SQLException, RuntimeException)
 {
@@ -165,7 +165,7 @@ Reference< XResultSetMetaData > SAL_CALL OPreparedStatement::getMetaData(  ) thr
     return m_xMetaData;
 }
 
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OPreparedStatement::execute(  ) throw(SQLException, RuntimeException)
 {
     SAL_INFO("connectivity.mork", "=> OPreparedStatement::execute()" );
@@ -175,7 +175,7 @@ sal_Bool SAL_CALL OPreparedStatement::execute(  ) throw(SQLException, RuntimeExc
     Reference< XResultSet> xResult = executeQuery();
     return xResult.is();
 }
-// -------------------------------------------------------------------------
+
 
 sal_Int32 SAL_CALL OPreparedStatement::executeUpdate(  ) throw(SQLException, RuntimeException)
 {
@@ -184,7 +184,7 @@ sal_Int32 SAL_CALL OPreparedStatement::executeUpdate(  ) throw(SQLException, Run
     ::dbtools::throwFeatureNotImplementedException( "XStatement::executeUpdate", *this );
     return 0;
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setString( sal_Int32 parameterIndex, const OUString& x ) throw(SQLException, RuntimeException)
 {
@@ -194,7 +194,7 @@ void SAL_CALL OPreparedStatement::setString( sal_Int32 parameterIndex, const OUS
     OSL_TRACE("prepStmt::setString( %s )", OUtoCStr( x ) );
     setParameter( parameterIndex, x );
 }
-// -------------------------------------------------------------------------
+
 
 Reference< XConnection > SAL_CALL OPreparedStatement::getConnection(  ) throw(SQLException, RuntimeException)
 {
@@ -203,7 +203,7 @@ Reference< XConnection > SAL_CALL OPreparedStatement::getConnection(  ) throw(SQ
 
     return (Reference< XConnection >)m_pConnection;
 }
-// -------------------------------------------------------------------------
+
 
 Reference< XResultSet > SAL_CALL OPreparedStatement::executeQuery(  ) throw(SQLException, RuntimeException)
 {
@@ -217,62 +217,62 @@ Reference< XResultSet > SAL_CALL OPreparedStatement::executeQuery(  ) throw(SQLE
     // stuff again. Just execute.
     return impl_executeCurrentQuery();
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setBoolean( sal_Int32 /*parameterIndex*/, sal_Bool /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBoolean", *this );
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OPreparedStatement::setByte( sal_Int32 /*parameterIndex*/, sal_Int8 /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setByte", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setDate( sal_Int32 /*parameterIndex*/, const Date& /*aData*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setDate", *this );
 }
-// -------------------------------------------------------------------------
+
 
 
 void SAL_CALL OPreparedStatement::setTime( sal_Int32 /*parameterIndex*/, const Time& /*aVal*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setTime", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setTimestamp( sal_Int32 /*parameterIndex*/, const DateTime& /*aVal*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setTimestamp", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setDouble( sal_Int32 /*parameterIndex*/, double /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setDouble", *this );
 }
 
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setFloat( sal_Int32 /*parameterIndex*/, float /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setFloat", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setInt( sal_Int32 /*parameterIndex*/, sal_Int32 /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setInt", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setLong( sal_Int32 /*parameterIndex*/, sal_Int64 /*aVal*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setLong", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 /*sqlType*/ ) throw(SQLException, RuntimeException)
 {
@@ -283,79 +283,79 @@ void SAL_CALL OPreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 /
 
     (m_aParameterRow->get())[parameterIndex].setNull();
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setClob( sal_Int32 /*parameterIndex*/, const Reference< XClob >& /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setClob", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setBlob( sal_Int32 /*parameterIndex*/, const Reference< XBlob >& /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBlob", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setArray( sal_Int32 /*parameterIndex*/, const Reference< XArray >& /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setArray", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setRef( sal_Int32 /*parameterIndex*/, const Reference< XRef >& /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setRef", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setObjectWithInfo( sal_Int32 /*parameterIndex*/, const Any& /*x*/, sal_Int32 /*sqlType*/, sal_Int32 /*scale*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setObjectWithInfo", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const OUString& /*typeName*/ ) throw(SQLException, RuntimeException)
 {
     setNull(parameterIndex,sqlType);
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setObject( sal_Int32 parameterIndex, const Any& x ) throw(SQLException, RuntimeException)
 {
     ::dbtools::implSetObject(this,parameterIndex,x);
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setShort( sal_Int32 /*parameterIndex*/, sal_Int16 /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setShort", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setBytes( sal_Int32 /*parameterIndex*/, const Sequence< sal_Int8 >& /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBytes", *this );
 }
-// -------------------------------------------------------------------------
+
 
 
 void SAL_CALL OPreparedStatement::setCharacterStream( sal_Int32 /*parameterIndex*/, const Reference< ::com::sun::star::io::XInputStream >& /*x*/, sal_Int32 /*length*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setCharacterStream", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::setBinaryStream( sal_Int32 /*parameterIndex*/, const Reference< ::com::sun::star::io::XInputStream >& /*x*/, sal_Int32 /*length*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBinaryStream", *this );
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OPreparedStatement::clearParameters(  ) throw(SQLException, RuntimeException)
 {
 }
-// -------------------------------------------------------------------------
+
 void OPreparedStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception)
 {
     switch(nHandle)
@@ -373,7 +373,7 @@ void OPreparedStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,cons
     }
 }
 
-// -----------------------------------------------------------------------------
+
 void OPreparedStatement::checkAndResizeParameters(sal_Int32 parameterIndex)
 {
     ::connectivity::checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
@@ -386,7 +386,7 @@ void OPreparedStatement::checkAndResizeParameters(sal_Int32 parameterIndex)
     if ((sal_Int32)(m_aParameterRow->get()).size() <= parameterIndex)
         (m_aParameterRow->get()).resize(parameterIndex+1);
 }
-// -----------------------------------------------------------------------------
+
 void OPreparedStatement::setParameter(sal_Int32 parameterIndex, const
 ORowSetValue& x)
 {
@@ -397,7 +397,7 @@ ORowSetValue& x)
     (m_aParameterRow->get())[parameterIndex] = x;
 }
 
-//------------------------------------------------------------------
+
 size_t OPreparedStatement::AddParameter(OSQLParseNode * pParameter, const Reference<XPropertySet>& _xCol)
 {
     OSL_UNUSED( pParameter );
@@ -449,7 +449,7 @@ size_t OPreparedStatement::AddParameter(OSQLParseNode * pParameter, const Refere
     m_xParamColumns->get().push_back(xParaColumn);
     return nParameter;
 }
-// -----------------------------------------------------------------------------
+
 void OPreparedStatement::describeColumn(OSQLParseNode*
 _pParameter,OSQLParseNode* _pNode,const OSQLTable& _xTable)
 {
@@ -469,7 +469,7 @@ _pParameter,OSQLParseNode* _pNode,const OSQLTable& _xTable)
     //  else
         //  AddParameter(_pParameter,xProp);
 }
-// -------------------------------------------------------------------------
+
 void OPreparedStatement::describeParameter()
 {
     ::std::vector< OSQLParseNode*> aParseNodes;
@@ -491,7 +491,7 @@ aParseNodes.begin();
     }
 }
 
-// -----------------------------------------------------------------------------
+
 void OPreparedStatement::scanParameter(OSQLParseNode* pParseNode,::std::vector< OSQLParseNode*>& _rParaNodes)
 {
     OSL_ENSURE(pParseNode != NULL,"OResultSet: internal error: invalid ParseNode");
@@ -511,22 +511,22 @@ void OPreparedStatement::scanParameter(OSQLParseNode* pParseNode,::std::vector<
     for (sal_uInt32 i = 0; i < pParseNode->count(); i++)
         scanParameter(pParseNode->getChild(i),_rParaNodes);
 }
-// -----------------------------------------------------------------------------
+
 ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSet > SAL_CALL OPreparedStatement::getResultSet(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
     return NULL;
 }
-// -----------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL OPreparedStatement::getUpdateCount(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
     return 0;
 }
-// -----------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OPreparedStatement::getMoreResults(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
     return sal_False;
 }
-// -----------------------------------------------------------------------------
+
 
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MQueryHelper.cxx b/connectivity/source/drivers/mork/MQueryHelper.cxx
index 05dd1219f6fc..8f09d46aacdb 100644
--- a/connectivity/source/drivers/mork/MQueryHelper.cxx
+++ b/connectivity/source/drivers/mork/MQueryHelper.cxx
@@ -92,7 +92,7 @@ MQueryHelper::~MQueryHelper()
     OSL_TRACE("OUT MQueryHelper::~MQueryHelper()");
 }
 
-// -------------------------------------------------------------------------
+
 void MQueryHelper::setAddressbook(OUString &ab)
 {
     SAL_INFO("connectivity.mork", "MQueryHelper::setAddressbook()");
@@ -103,7 +103,7 @@ void MQueryHelper::setAddressbook(OUString &ab)
 
     OSL_TRACE("\tOUT MQuery::setAddressbook()");
 }
-// -------------------------------------------------------------------------
+
 void MQueryHelper::setExpression( MQueryExpression &_expr )
 {
     SAL_INFO("connectivity.mork", "MQueryHelper::setExpression()");
@@ -164,7 +164,7 @@ sal_Int32 MQueryHelper::getResultCount() const
     return result;
 }
 
-// -------------------------------------------------------------------------
+
 
 sal_Bool MQueryHelper::queryComplete() const
 {
diff --git a/connectivity/source/drivers/mork/MResultSet.cxx b/connectivity/source/drivers/mork/MResultSet.cxx
index 7baac6653c6e..d2c4b1c610af 100644
--- a/connectivity/source/drivers/mork/MResultSet.cxx
+++ b/connectivity/source/drivers/mork/MResultSet.cxx
@@ -61,13 +61,13 @@ using namespace com::sun::star::container;
 using namespace com::sun::star::io;
 using namespace com::sun::star::util;
 
-//------------------------------------------------------------------------------
+
 //  IMPLEMENT_SERVICE_INFO(OResultSet,"com.sun.star.sdbcx.OResultSet","com.sun.star.sdbc.ResultSet");
 OUString SAL_CALL OResultSet::getImplementationName(  ) throw ( RuntimeException)    \
 {
     return OUString("com.sun.star.sdbcx.mork.ResultSet");
 }
-// -------------------------------------------------------------------------
+
  Sequence< OUString > SAL_CALL OResultSet::getSupportedServiceNames(  ) throw( RuntimeException)
 {
     ::com::sun::star::uno::Sequence< OUString > aSupported(2);
@@ -81,7 +81,7 @@ sal_Bool SAL_CALL OResultSet::supportsService( const OUString& _rServiceName ) t
     return cppu::supportsService(this, _rServiceName);
 }
 
-// -------------------------------------------------------------------------
+
 OResultSet::OResultSet(OCommonStatement* pStmt, const ::boost::shared_ptr< connectivity::OSQLParseTreeIterator >& _pSQLIterator )
     : OResultSet_BASE(m_aMutex)
     ,OPropertySetHelper(OResultSet_BASE::rBHelper)
@@ -111,12 +111,12 @@ OResultSet::OResultSet(OCommonStatement* pStmt, const ::boost::shared_ptr< conne
 {
     //m_aQuery.setMaxNrOfReturns(pStmt->getOwnConnection()->getMaxResultRecords());
 }
-// -------------------------------------------------------------------------
+
 OResultSet::~OResultSet()
 {
 }
 
-// -------------------------------------------------------------------------
+
 void OResultSet::disposing(void)
 {
     OPropertySetHelper::disposing();
@@ -135,7 +135,7 @@ void OResultSet::disposing(void)
         m_pTable = NULL;
     }
 }
-// -------------------------------------------------------------------------
+
 Any SAL_CALL OResultSet::queryInterface( const Type & rType ) throw(RuntimeException)
 {
     Any aRet = OPropertySetHelper::queryInterface(rType);
@@ -143,7 +143,7 @@ Any SAL_CALL OResultSet::queryInterface( const Type & rType ) throw(RuntimeExcep
         aRet = OResultSet_BASE::queryInterface(rType);
     return aRet;
 }
-// -------------------------------------------------------------------------
+
  Sequence<  Type > SAL_CALL OResultSet::getTypes(  ) throw( RuntimeException)
 {
     OTypeCollection aTypes( ::getCppuType( (const  Reference< ::com::sun::star::beans::XMultiPropertySet > *)0 ),
@@ -152,7 +152,7 @@ Any SAL_CALL OResultSet::queryInterface( const Type & rType ) throw(RuntimeExcep
 
     return ::comphelper::concatSequences(aTypes.getTypes(),OResultSet_BASE::getTypes());
 }
-// -------------------------------------------------------------------------
+
 void OResultSet::methodEntry()
 {
     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
@@ -163,7 +163,7 @@ void OResultSet::methodEntry()
     }
 }
 
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL OResultSet::findColumn( const OUString& columnName ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
@@ -183,60 +183,60 @@ sal_Int32 SAL_CALL OResultSet::findColumn( const OUString& columnName ) throw(SQ
     assert(false);
     return 0; // Never reached
 }
-// -------------------------------------------------------------------------
+
 Reference< XInputStream > SAL_CALL OResultSet::getBinaryStream( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     return NULL;
 }
-// -------------------------------------------------------------------------
+
 Reference< XInputStream > SAL_CALL OResultSet::getCharacterStream( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     return NULL;
 }
 
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OResultSet::getBoolean( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
     m_bWasNull = sal_True;
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 
 sal_Int8 SAL_CALL OResultSet::getByte( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
     return 0;
 }
-// -------------------------------------------------------------------------
+
 
 Sequence< sal_Int8 > SAL_CALL OResultSet::getBytes( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
     return Sequence< sal_Int8 >();
 }
-// -------------------------------------------------------------------------
+
 
 Date SAL_CALL OResultSet::getDate( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
     return Date();
 }
-// -------------------------------------------------------------------------
+
 
 double SAL_CALL OResultSet::getDouble( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
     return 0.0;
 }
-// -------------------------------------------------------------------------
+
 
 float SAL_CALL OResultSet::getFloat( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
     return 0;
 }
-// -------------------------------------------------------------------------
+
 
 sal_Int32 SAL_CALL OResultSet::getInt( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
@@ -244,7 +244,7 @@ sal_Int32 SAL_CALL OResultSet::getInt( sal_Int32 /*columnIndex*/ ) throw(SQLExce
     return 0;
 }
 
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL OResultSet::getRow(  ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
@@ -252,14 +252,14 @@ sal_Int32 SAL_CALL OResultSet::getRow(  ) throw(SQLException, RuntimeException)
     OSL_TRACE("In/Out: OResultSet::getRow, return = %u", m_nRowPos );
     return m_nRowPos;
 }
-// -------------------------------------------------------------------------
+
 
 sal_Int64 SAL_CALL OResultSet::getLong( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
     return sal_Int64();
 }
-// -------------------------------------------------------------------------
+
 
 Reference< XResultSetMetaData > SAL_CALL OResultSet::getMetaData(  ) throw(SQLException, RuntimeException)
 {
@@ -270,49 +270,49 @@ Reference< XResultSetMetaData > SAL_CALL OResultSet::getMetaData(  ) throw(SQLEx
         m_pSQLIterator->getSelectColumns(), m_pSQLIterator->getTables().begin()->first ,m_pTable,determineReadOnly());
     return m_xMetaData;
 }
-// -------------------------------------------------------------------------
+
 Reference< XArray > SAL_CALL OResultSet::getArray( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     return NULL;
 }
 
-// -------------------------------------------------------------------------
+
 
 Reference< XClob > SAL_CALL OResultSet::getClob( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     return NULL;
 }
-// -------------------------------------------------------------------------
+
 Reference< XBlob > SAL_CALL OResultSet::getBlob( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     return NULL;
 }
-// -------------------------------------------------------------------------
+
 
 Reference< XRef > SAL_CALL OResultSet::getRef( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     return NULL;
 }
-// -------------------------------------------------------------------------
+
 
 Any SAL_CALL OResultSet::getObject( sal_Int32 /*columnIndex*/, const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException)
 {
     return Any();
 }
-// -------------------------------------------------------------------------
+
 
 sal_Int16 SAL_CALL OResultSet::getShort( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     return 0;
 }
-// -------------------------------------------------------------------------
+
 
 void OResultSet::checkIndex(sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException)
 {
     if(columnIndex <= 0 || columnIndex > (sal_Int32)m_xColumns->get().size())
         ::dbtools::throwInvalidIndexException(*this);
 }
-// -------------------------------------------------------------------------
+
 sal_uInt32 OResultSet::currentRowCount()
 {
     if ( m_bIsAlwaysFalseQuery )
@@ -322,7 +322,7 @@ sal_uInt32 OResultSet::currentRowCount()
     return m_aQueryHelper.getResultCount();
 }
 
-// -------------------------------------------------------------------------
+
 
 sal_Bool OResultSet::fetchCurrentRow( ) throw(SQLException, RuntimeException)
 {
@@ -330,7 +330,7 @@ sal_Bool OResultSet::fetchCurrentRow( ) throw(SQLException, RuntimeException)
     return fetchRow(getCurrentCardNumber());
 }
 
-// -------------------------------------------------------------------------
+
 sal_Bool OResultSet::pushCard(sal_uInt32 /*cardNumber*/) throw(SQLException, RuntimeException)
 {
     SAL_INFO("connectivity.mork", "=> OResultSet::pushCard()" );
@@ -360,7 +360,7 @@ sal_Bool OResultSet::pushCard(sal_uInt32 /*cardNumber*/) throw(SQLException, Run
     return sal_True;
 */
 }
-// -------------------------------------------------------------------------
+
 sal_Bool OResultSet::fetchRow(sal_Int32 cardNumber,sal_Bool bForceReload) throw(SQLException, RuntimeException)
 {
     SAL_INFO("connectivity.mork", "=> OResultSet::fetchRow()" );
@@ -404,7 +404,7 @@ sal_Bool OResultSet::fetchRow(sal_Int32 cardNumber,sal_Bool bForceReload) throw(
     return sal_True;
 
 }
-// -------------------------------------------------------------------------
+
 
 const ORowSetValue& OResultSet::getValue(sal_Int32 cardNumber, sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 {
@@ -419,7 +419,7 @@ const ORowSetValue& OResultSet::getValue(sal_Int32 cardNumber, sal_Int32 columnI
     return (m_aRow->get())[columnIndex];
 
 }
-// -------------------------------------------------------------------------
+
 
 
 OUString SAL_CALL OResultSet::getString( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
@@ -434,14 +434,14 @@ OUString SAL_CALL OResultSet::getString( sal_Int32 columnIndex ) throw(SQLExcept
     return getValue(getCurrentCardNumber(), mapColumn( columnIndex ) );
 
 }
-// -------------------------------------------------------------------------
+
 
 Time SAL_CALL OResultSet::getTime( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
     return Time();
 }
-// -------------------------------------------------------------------------
+
 
 
 DateTime SAL_CALL OResultSet::getTimestamp( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
@@ -449,7 +449,7 @@ DateTime SAL_CALL OResultSet::getTimestamp( sal_Int32 /*columnIndex*/ ) throw(SQ
     ResultSetEntryGuard aGuard( *this );
     return DateTime();
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSet::isBeforeFirst(  ) throw(SQLException, RuntimeException)
 {
@@ -460,7 +460,7 @@ sal_Bool SAL_CALL OResultSet::isBeforeFirst(  ) throw(SQLException, RuntimeExcep
     OSL_TRACE("In/Out: OResultSet::isBeforeFirst" );
     return( m_nRowPos < 1 );
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OResultSet::isAfterLast(  ) throw(SQLException, RuntimeException)
 {
     SAL_WARN("connectivity.mork", "OResultSet::isAfterLast() NOT IMPLEMENTED!");
@@ -470,7 +470,7 @@ sal_Bool SAL_CALL OResultSet::isAfterLast(  ) throw(SQLException, RuntimeExcepti
 //    return sal_True;
     return m_nRowPos > currentRowCount() && m_aQueryHelper.queryComplete();
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OResultSet::isFirst(  ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
@@ -478,7 +478,7 @@ sal_Bool SAL_CALL OResultSet::isFirst(  ) throw(SQLException, RuntimeException)
     OSL_TRACE("In/Out: OResultSet::isFirst" );
     return m_nRowPos == 1;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OResultSet::isLast(  ) throw(SQLException, RuntimeException)
 {
     SAL_WARN("connectivity.mork", "OResultSet::isLast() NOT IMPLEMENTED!");
@@ -488,7 +488,7 @@ sal_Bool SAL_CALL OResultSet::isLast(  ) throw(SQLException, RuntimeException)
 //    return sal_True;
     return m_nRowPos == currentRowCount() && m_aQueryHelper.queryComplete();
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::beforeFirst(  ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
@@ -498,7 +498,7 @@ void SAL_CALL OResultSet::beforeFirst(  ) throw(SQLException, RuntimeException)
     if ( first() )
         previous();
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::afterLast(  ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
@@ -507,47 +507,47 @@ void SAL_CALL OResultSet::afterLast(  ) throw(SQLException, RuntimeException)
     if(last())
         next();
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OResultSet::close() throw(SQLException, RuntimeException)
 {
     OSL_TRACE("In/Out: OResultSet::close" );
     dispose();
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSet::first(  ) throw(SQLException, RuntimeException)
 {
     OSL_TRACE("In/Out: OResultSet::first" );
     return seekRow( FIRST_POS );
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSet::last(  ) throw(SQLException, RuntimeException)
 {
     OSL_TRACE("In/Out: OResultSet::last" );
     return seekRow( LAST_POS );
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OResultSet::absolute( sal_Int32 row ) throw(SQLException, RuntimeException)
 {
     OSL_TRACE("In/Out: OResultSet::absolute" );
     return seekRow( ABSOLUTE_POS, row );
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OResultSet::relative( sal_Int32 row ) throw(SQLException, RuntimeException)
 {
     OSL_TRACE("In/Out: OResultSet::relative" );
     return seekRow( RELATIVE_POS, row );
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OResultSet::previous(  ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
     OSL_TRACE("In/Out: OResultSet::previous" );
     return seekRow( PRIOR_POS );
 }
-// -------------------------------------------------------------------------
+
 Reference< XInterface > SAL_CALL OResultSet::getStatement(  ) throw(SQLException, RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
@@ -555,7 +555,7 @@ Reference< XInterface > SAL_CALL OResultSet::getStatement(  ) throw(SQLException
     OSL_TRACE("In/Out: OResultSet::getStatement" );
     return m_xStatement;
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSet::rowDeleted(  ) throw(SQLException, RuntimeException)
 {
@@ -564,7 +564,7 @@ sal_Bool SAL_CALL OResultSet::rowDeleted(  ) throw(SQLException, RuntimeExceptio
     OSL_TRACE("In/Out: OResultSet::rowDeleted, m_RowStates=%u",m_RowStates );
     return sal_True;//return ((m_RowStates & RowStates_Deleted) == RowStates_Deleted) ;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OResultSet::rowInserted(  ) throw(SQLException, RuntimeException)
 {
     SAL_WARN("connectivity.mork", "OResultSet::rowInserted() NOT IMPLEMENTED!");
@@ -572,7 +572,7 @@ sal_Bool SAL_CALL OResultSet::rowInserted(  ) throw(SQLException, RuntimeExcepti
     OSL_TRACE("In/Out: OResultSet::rowInserted,m_RowStates=%u",m_RowStates );
     return sal_True;//return ((m_RowStates & RowStates_Inserted) == RowStates_Inserted);
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OResultSet::rowUpdated(  ) throw(SQLException, RuntimeException)
 {
     SAL_WARN("connectivity.mork", "OResultSet::rowUpdated() NOT IMPLEMENTED!");
@@ -580,13 +580,13 @@ sal_Bool SAL_CALL OResultSet::rowUpdated(  ) throw(SQLException, RuntimeExceptio
     OSL_TRACE("In/Out: OResultSet::rowUpdated,m_RowStates=%u",m_RowStates );
     return sal_True;// return ((m_RowStates & RowStates_Updated) == RowStates_Updated) ;
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSet::next(  ) throw(SQLException, RuntimeException)
 {
     return seekRow( NEXT_POS );
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSet::wasNull(  ) throw(SQLException, RuntimeException)
 {
@@ -594,7 +594,7 @@ sal_Bool SAL_CALL OResultSet::wasNull(  ) throw(SQLException, RuntimeException)
 
     return m_bWasNull;
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OResultSet::cancel(  ) throw(RuntimeException)
 {
@@ -602,18 +602,18 @@ void SAL_CALL OResultSet::cancel(  ) throw(RuntimeException)
     OSL_TRACE("In/Out: OResultSet::cancel" );
 
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::clearWarnings(  ) throw(SQLException, RuntimeException)
 {
     OSL_TRACE("In/Out: OResultSet::clearWarnings" );
 }
-// -------------------------------------------------------------------------
+
 Any SAL_CALL OResultSet::getWarnings(  ) throw(SQLException, RuntimeException)
 {
     OSL_TRACE("In/Out: OResultSet::getWarnings" );
     return Any();
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::refreshRow(  ) throw(SQLException, RuntimeException)
 {
     OSL_TRACE("In/Out: OResultSet::refreshRow" );
@@ -622,7 +622,7 @@ void SAL_CALL OResultSet::refreshRow(  ) throw(SQLException, RuntimeException)
         m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_REFRESH_ROW, *this );
     }
 }
-// -------------------------------------------------------------------------
+
 IPropertyArrayHelper* OResultSet::createArrayHelper( ) const
 {
     Sequence< Property > aProps(5);
@@ -636,12 +636,12 @@ IPropertyArrayHelper* OResultSet::createArrayHelper( ) const
 
     return new OPropertyArrayHelper(aProps);
 }
-// -------------------------------------------------------------------------
+
 IPropertyArrayHelper & OResultSet::getInfoHelper()
 {
     return *const_cast<OResultSet*>(this)->getArrayHelper();
 }
-// -------------------------------------------------------------------------
+
 sal_Bool OResultSet::convertFastPropertyValue(
                             Any & /*rConvertedValue*/,
                             Any & /*rOldValue*/,
@@ -663,7 +663,7 @@ sal_Bool OResultSet::convertFastPropertyValue(
     }
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 void OResultSet::setFastPropertyValue_NoBroadcast(
                                 sal_Int32 nHandle,
                                 const Any& /*rValue*/
@@ -685,7 +685,7 @@ void OResultSet::setFastPropertyValue_NoBroadcast(
             ;
     }
 }
-// -------------------------------------------------------------------------
+
 void OResultSet::getFastPropertyValue(
                                 Any& rValue,
                                 sal_Int32 nHandle
@@ -711,23 +711,23 @@ void OResultSet::getFastPropertyValue(
          break;
     }
 }
-// -----------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::acquire() throw()
 {
     OResultSet_BASE::acquire();
 }
-// -----------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::release() throw()
 {
     OResultSet_BASE::release();
 }
-// -----------------------------------------------------------------------------
+
 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OResultSet::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
 {
     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 }
 
-// -------------------------------------------------------------------------
+
 void OResultSet::parseParameter( const OSQLParseNode* pNode, OUString& rMatchString )
 {
     OSL_ENSURE(pNode->count() > 0,"Error parsing parameter in Parse Tree");
@@ -1051,7 +1051,7 @@ void OResultSet::analyseWhereClause( const OSQLParseNode*                 parseT
     }
 }
 
-// -----------------------------------------------------------------------------
+
 
 void OResultSet::fillRowData()
     throw( ::com::sun::star::sdbc::SQLException )
@@ -1123,7 +1123,7 @@ void OResultSet::fillRowData()
 #endif
 }
 
-// -----------------------------------------------------------------------------
+
 static sal_Bool matchRow( OValueRow& row1, OValueRow& row2 )
 {
     OValueVector::Vector::iterator row1Iter = row1->get().begin();
@@ -1165,7 +1165,7 @@ sal_Int32 OResultSet::getRowForCardNumber(sal_Int32 nCardNum)
     return 0;
 }
 
-// -----------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::executeQuery() throw( ::com::sun::star::sdbc::SQLException,
                                                 ::com::sun::star::uno::RuntimeException)
 {
@@ -1335,7 +1335,7 @@ void SAL_CALL OResultSet::executeQuery() throw( ::com::sun::star::sdbc::SQLExcep
     }
 }
 
-// -----------------------------------------------------------------------------
+
 
 
 void OResultSet::setBoundedColumns(const OValueRow& _rRow,
@@ -1418,7 +1418,7 @@ void OResultSet::setBoundedColumns(const OValueRow& _rRow,
 }
 
 
-// -----------------------------------------------------------------------------
+
 sal_Bool OResultSet::isCount() const
 {
     return (m_pParseTree &&
@@ -1430,7 +1430,7 @@ sal_Bool OResultSet::isCount() const
             );
 }
 
-// -----------------------------------------------------------------------------
+
 //
 // Check for valid row in m_aQuery
 //
@@ -1489,7 +1489,7 @@ sal_Int32 OResultSet::deletedCount()
     return m_CurrentRowCount - static_cast<sal_Int32>(m_pKeySet->get().size());
 
 }
-// -----------------------------------------------------------------------------
+
 sal_Bool OResultSet::seekRow( eRowPosition pos, sal_Int32 nOffset )
 {
     SAL_INFO("connectivity.mork", "=> OResultSet::seekRow()" );
@@ -1559,7 +1559,7 @@ sal_Bool OResultSet::seekRow( eRowPosition pos, sal_Int32 nOffset )
     fetchCurrentRow();
     return sal_True;
 }
-// -----------------------------------------------------------------------------
+
 void OResultSet::setColumnMapping(const ::std::vector<sal_Int32>& _aColumnMapping)
 {
     m_aColMapping = _aColumnMapping;
@@ -1568,7 +1568,7 @@ void OResultSet::setColumnMapping(const ::std::vector<sal_Int32>& _aColumnMappin
         OSL_TRACE("Set Mapped: %d -> %d", i, m_aColMapping[i] );
 #endif
 }
-// -----------------------------------------------------------------------------
+
 
 ::com::sun::star::uno::Any OResultSet::getBookmark(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
@@ -1677,7 +1677,7 @@ void OResultSet::updateValue(sal_Int32 columnIndex ,const ORowSetValue& x) throw
     m_nUpdatedRow = getCurrentCardNumber();
 //    m_RowStates = m_RowStates | RowStates_Updated;
 }
-// -----------------------------------------------------------------------------
+
 
 void SAL_CALL OResultSet::updateNull( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 {
@@ -1695,72 +1695,72 @@ void SAL_CALL OResultSet::updateNull( sal_Int32 columnIndex ) throw(SQLException
     m_nUpdatedRow = getCurrentCardNumber();
 //    m_RowStates = m_RowStates | RowStates_Updated;
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OResultSet::updateBoolean( sal_Int32 columnIndex, sal_Bool x ) throw(SQLException, RuntimeException)
 {
     updateValue(columnIndex, static_cast<bool>(x));
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::updateByte( sal_Int32 columnIndex, sal_Int8 x ) throw(SQLException, RuntimeException)
 {
     updateValue(columnIndex,x);
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OResultSet::updateShort( sal_Int32 columnIndex, sal_Int16 x ) throw(SQLException, RuntimeException)
 {
     updateValue(columnIndex,x);
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::updateInt( sal_Int32 columnIndex, sal_Int32 x ) throw(SQLException, RuntimeException)
 {
     updateValue(columnIndex,x);
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::updateLong( sal_Int32 /*columnIndex*/, sal_Int64 /*x*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XRowUpdate::updateLong", *this );
 }
-// -----------------------------------------------------------------------
+
 void SAL_CALL OResultSet::updateFloat( sal_Int32 columnIndex, float x ) throw(SQLException, RuntimeException)
 {
     updateValue(columnIndex,x);
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OResultSet::updateDouble( sal_Int32 columnIndex, double x ) throw(SQLException, RuntimeException)
 {
     updateValue(columnIndex,x);
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::updateString( sal_Int32 columnIndex, const OUString& x ) throw(SQLException, RuntimeException)
 {
     updateValue(columnIndex,x);
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::updateBytes( sal_Int32 columnIndex, const Sequence< sal_Int8 >& x ) throw(SQLException, RuntimeException)
 {
     updateValue(columnIndex,x);
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::updateDate( sal_Int32 columnIndex, const ::com::sun::star::util::Date& x ) throw(SQLException, RuntimeException)
 {
     updateValue(columnIndex,x);
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OResultSet::updateTime( sal_Int32 columnIndex, const ::com::sun::star::util::Time& x ) throw(SQLException, RuntimeException)
 {
     updateValue(columnIndex,x);
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OResultSet::updateTimestamp( sal_Int32 columnIndex, const ::com::sun::star::util::DateTime& x ) throw(SQLException, RuntimeException)
 {
     updateValue(columnIndex,x);
 }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OResultSet::updateBinaryStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
 {
@@ -1773,12 +1773,12 @@ void SAL_CALL OResultSet::updateBinaryStream( sal_Int32 columnIndex, const Refer
     x->readBytes(aSeq,length);
     updateValue(columnIndex,aSeq);
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::updateCharacterStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
 {
     updateBinaryStream(columnIndex,x,length);
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::updateObject( sal_Int32 columnIndex, const Any& x ) throw(SQLException, RuntimeException)
 {
     if (!::dbtools::implUpdateObject(this, columnIndex, x))
@@ -1790,7 +1790,7 @@ void SAL_CALL OResultSet::updateObject( sal_Int32 columnIndex, const Any& x ) th
         ::dbtools::throwGenericSQLException(sError,*this);
     } // if (!::dbtools::implUpdateObject(this, columnIndex, x))
  }
-// -------------------------------------------------------------------------
+
 
 void SAL_CALL OResultSet::updateNumericObject( sal_Int32 columnIndex, const Any& x, sal_Int32 /*scale*/ ) throw(SQLException, RuntimeException)
 {
@@ -1805,7 +1805,7 @@ void SAL_CALL OResultSet::updateNumericObject( sal_Int32 columnIndex, const Any&
 }
 
 // XResultSetUpdate
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::insertRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
@@ -1817,27 +1817,27 @@ void SAL_CALL OResultSet::insertRow(  ) throw(::com::sun::star::sdbc::SQLExcepti
     //m_aQueryHelper.setRowStates(getCurrentCardNumber(),m_RowStates);
     OSL_TRACE("insertRow out, m_nRowPos = %u", m_nRowPos );
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::updateRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
     OSL_FAIL( "OResultSet::updateRow(  ) not implemented" );
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::deleteRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
     OSL_FAIL( "OResultSet::deleteRow(  ) not implemented" );
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::cancelRowUpdates(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
     OSL_FAIL( "OResultSet::cancelRowUpdates(  ) not implemented" );
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::moveToInsertRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
     OSL_FAIL( "OResultSet::moveToInsertRow(  ) not implemented" );
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OResultSet::moveToCurrentRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
     ResultSetEntryGuard aGuard( *this );
diff --git a/connectivity/source/drivers/mork/MResultSetMetaData.cxx b/connectivity/source/drivers/mork/MResultSetMetaData.cxx
index 2e7763227c12..4aa8faec1542 100644
--- a/connectivity/source/drivers/mork/MResultSetMetaData.cxx
+++ b/connectivity/source/drivers/mork/MResultSetMetaData.cxx
@@ -34,48 +34,48 @@ using namespace com::sun::star::beans;
 using namespace ::dbtools;
 using namespace ::comphelper;
 
-// -------------------------------------------------------------------------
+
 OResultSetMetaData::~OResultSetMetaData()
 {
    m_xColumns = NULL;
 }
 
-// -----------------------------------------------------------------------------
+
 void OResultSetMetaData::checkColumnIndex(sal_Int32 column)  throw(SQLException, RuntimeException)
 {
     if(column <= 0 || column > (sal_Int32)(sal_Int32)m_xColumns->get().size())
         throwInvalidIndexException(*this);
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL OResultSetMetaData::getColumnDisplaySize( sal_Int32 column ) throw(SQLException, RuntimeException)
 {
     return getPrecision(column);
 }
-// -------------------------------------------------------------------------
+
 
 sal_Int32 SAL_CALL OResultSetMetaData::getColumnType( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
 {
     return DataType::VARCHAR; // at the moment there exists only this type
 }
-// -------------------------------------------------------------------------
+
 
 sal_Int32 SAL_CALL OResultSetMetaData::getColumnCount(  ) throw(SQLException, RuntimeException)
 {
     return static_cast<sal_Int32>((m_xColumns->get()).size());
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSetMetaData::isCaseSensitive( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 
 OUString SAL_CALL OResultSetMetaData::getSchemaName( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
 {
     return OUString();
 }
-// -------------------------------------------------------------------------
+
 
 OUString SAL_CALL OResultSetMetaData::getColumnName( sal_Int32 column ) throw(SQLException, RuntimeException)
 {
@@ -93,70 +93,70 @@ OUString SAL_CALL OResultSetMetaData::getColumnName( sal_Int32 column ) throw(SQ
     }
     return sColumnName;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL OResultSetMetaData::getTableName( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
 {
     return m_aTableName;
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL OResultSetMetaData::getCatalogName( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
 {
     return OUString();
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL OResultSetMetaData::getColumnTypeName( sal_Int32 column ) throw(SQLException, RuntimeException)
 {
     checkColumnIndex(column);
     return getString((m_xColumns->get())[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPENAME)));
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL OResultSetMetaData::getColumnLabel( sal_Int32 column ) throw(SQLException, RuntimeException)
 {
     return getColumnName(column);
 }
-// -------------------------------------------------------------------------
+
 OUString SAL_CALL OResultSetMetaData::getColumnServiceName( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
 {
     return OUString();
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSetMetaData::isCurrency( sal_Int32 column ) throw(SQLException, RuntimeException)
 {
     checkColumnIndex(column);
     return getBOOL((m_xColumns->get())[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)));
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSetMetaData::isAutoIncrement( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OResultSetMetaData::isSigned( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
 {
     return sal_False;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL OResultSetMetaData::getPrecision( sal_Int32 column ) throw(SQLException, RuntimeException)
 {
     checkColumnIndex(column);
     return getINT32((m_xColumns->get())[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION)));
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL OResultSetMetaData::getScale( sal_Int32 column ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
     checkColumnIndex(column);
     return getINT32((m_xColumns->get())[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE)));
 }
-// -------------------------------------------------------------------------
+
 
 sal_Int32 SAL_CALL OResultSetMetaData::isNullable( sal_Int32 column ) throw(SQLException, RuntimeException)
 {
     checkColumnIndex(column);
     return getINT32((m_xColumns->get())[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE)));
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSetMetaData::isSearchable( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
 {
@@ -168,7 +168,7 @@ sal_Bool SAL_CALL OResultSetMetaData::isSearchable( sal_Int32 /*column*/ ) throw
 
     return sal_True;
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSetMetaData::isReadOnly( sal_Int32 column ) throw(SQLException, RuntimeException)
 {
@@ -178,17 +178,17 @@ sal_Bool SAL_CALL OResultSetMetaData::isReadOnly( sal_Int32 column ) throw(SQLEx
 
     return m_bReadOnly || bReadOnly || m_pTable->isReadOnly();
 }
-// -------------------------------------------------------------------------
+
 
 sal_Bool SAL_CALL OResultSetMetaData::isDefinitelyWritable( sal_Int32 column ) throw(SQLException, RuntimeException)
 {
     return !isReadOnly(column);
 }
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OResultSetMetaData::isWritable( sal_Int32 column ) throw(SQLException, RuntimeException)
 {
     return !isReadOnly(column);
 }
-// -------------------------------------------------------------------------
+
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MStatement.cxx b/connectivity/source/drivers/mork/MStatement.cxx
index 0d719b591efb..403ae0b648b7 100644
--- a/connectivity/source/drivers/mork/MStatement.cxx
+++ b/connectivity/source/drivers/mork/MStatement.cxx
@@ -59,7 +59,7 @@ static ::osl::Mutex m_ThreadMutex;
 using namespace ::comphelper;
 using namespace connectivity::mork;
 using namespace connectivity;
-//------------------------------------------------------------------------------
+
 using namespace com::sun::star::uno;
 using namespace com::sun::star::lang;
 using namespace com::sun::star::beans;
@@ -67,7 +67,7 @@ using namespace com::sun::star::sdbc;
 using namespace com::sun::star::container;
 using namespace com::sun::star::io;
 using namespace com::sun::star::util;
-//------------------------------------------------------------------------------
+
 
 OStatement::OStatement( OConnection* _pConnection) : OCommonStatement( _pConnection)
 {
@@ -90,12 +90,12 @@ OCommonStatement::OCommonStatement(OConnection* _pConnection )
     m_pConnection->acquire();
 }
 
-// -----------------------------------------------------------------------------
+
 OCommonStatement::~OCommonStatement()
 {
 }
 
-//------------------------------------------------------------------------------
+
 void OCommonStatement::disposing()
 {
     ::osl::MutexGuard aGuard(m_aMutex);
@@ -112,7 +112,7 @@ void OCommonStatement::disposing()
     dispose_ChildImpl();
     OCommonStatement_IBASE::disposing();
 }
-//-----------------------------------------------------------------------------
+
 Any SAL_CALL OCommonStatement::queryInterface( const Type & rType ) throw(RuntimeException)
 {
     Any aRet = OCommonStatement_IBASE::queryInterface(rType);
@@ -120,7 +120,7 @@ Any SAL_CALL OCommonStatement::queryInterface( const Type & rType ) throw(Runtim
         aRet = OPropertySetHelper::queryInterface(rType);
     return aRet;
 }
-// -------------------------------------------------------------------------
+
 Sequence< Type > SAL_CALL OCommonStatement::getTypes(  ) throw(RuntimeException)
 {
     ::cppu::OTypeCollection aTypes( ::getCppuType( (const Reference< XMultiPropertySet > *)0 ),
@@ -129,7 +129,7 @@ Sequence< Type > SAL_CALL OCommonStatement::getTypes(  ) throw(RuntimeException)
 
     return ::comphelper::concatSequences(aTypes.getTypes(),OCommonStatement_IBASE::getTypes());
 }
-// -------------------------------------------------------------------------
+
 void SAL_CALL OCommonStatement::close(  ) throw(SQLException, RuntimeException)
 {
     {
@@ -140,7 +140,7 @@ void SAL_CALL OCommonStatement::close(  ) throw(SQLException, RuntimeException)
 }
 
 
-// -------------------------------------------------------------------------
+
 void OCommonStatement::createTable( ) throw ( SQLException, RuntimeException )
 {
     SAL_INFO("connectivity.mork", "=>  OCommonStatement::createTable()" );
@@ -189,7 +189,7 @@ void OCommonStatement::createTable( ) throw ( SQLException, RuntimeException )
         getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
 */
 }
-// -------------------------------------------------------------------------
+
 OCommonStatement::StatementType OCommonStatement::parseSql( const OUString& sql , sal_Bool bAdjusted)
     throw ( SQLException, RuntimeException )
 {
@@ -266,7 +266,7 @@ OCommonStatement::StatementType OCommonStatement::parseSql( const OUString& sql
     return eSelect;
 
 }
-// -------------------------------------------------------------------------
+
 Reference< XResultSet > OCommonStatement::impl_executeCurrentQuery()
 {
     SAL_INFO("connectivity.mork", "=>  OCommonStatement::impl_executeCurrentQuery()" );
@@ -283,7 +283,7 @@ Reference< XResultSet > OCommonStatement::impl_executeCurrentQuery()
 
 }
 
-// -------------------------------------------------------------------------
+
 void OCommonStatement::initializeResultSet( OResultSet* _pResult )
 {
     SAL_INFO("connectivity.mork", "=>  OCommonStatement::initializeResultSet()" );
@@ -297,7 +297,7 @@ void OCommonStatement::initializeResultSet( OResultSet* _pResult )
     _pResult->setTable(m_pTable);
 }
 
-// -------------------------------------------------------------------------
+
 void OCommonStatement::clearCachedResultSet()
 {
     SAL_INFO("connectivity.mork", "=>  OCommonStatement::clearCachedResultSet()" );
@@ -311,14 +311,14 @@ void OCommonStatement::clearCachedResultSet()
     m_xResultSet.clear();
 }
 
-// -------------------------------------------------------------------------
+
 void OCommonStatement::cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult )
 {
     ENSURE_OR_THROW( _pResult.is(), "invalid result set" );
     m_xResultSet = Reference< XResultSet >( _pResult.get() );
 }
 
-// -------------------------------------------------------------------------
+
 sal_Bool SAL_CALL OCommonStatement::execute( const OUString& sql ) throw(SQLException, RuntimeException)
 {
     SAL_INFO("connectivity.mork", "=>  OCommonStatement::execute()" );
@@ -332,7 +332,7 @@ sal_Bool SAL_CALL OCommonStatement::execute( const OUString& sql ) throw(SQLExce
     // returns true when a resultset is available
     return xRS.is();
 }
-// -------------------------------------------------------------------------
+
 
 Reference< XResultSet > SAL_CALL OCommonStatement::executeQuery( const OUString& sql ) throw(SQLException, RuntimeException)
 {
@@ -350,7 +350,7 @@ Reference< XResultSet > SAL_CALL OCommonStatement::executeQuery( const OUString&
 
     return impl_executeCurrentQuery();
 }
-// -------------------------------------------------------------------------
+
 
 Reference< XConnection > SAL_CALL OCommonStatement::getConnection(  ) throw(SQLException, RuntimeException)
 {
@@ -362,7 +362,7 @@ Reference< XConnection > SAL_CALL OCommonStatement::getConnection(  ) throw(SQLE
     // just return our connection here
     return (Reference< XConnection >)m_pConnection;
 }
-// -----------------------------------------------------------------------------
+
 Any SAL_CALL OStatement::queryInterface( const Type & rType ) throw(RuntimeException)
 {
     SAL_INFO("connectivity.mork", "=>  OCommonStatement::queryInterface()" );
@@ -372,14 +372,14 @@ Any SAL_CALL OStatement::queryInterface( const Type & rType ) throw(RuntimeExcep
         aRet = OCommonStatement::queryInterface(rType);
     return aRet;
 }
-// -------------------------------------------------------------------------
+
 sal_Int32 SAL_CALL OCommonStatement::executeUpdate( const OUString& /*sql*/ ) throw(SQLException, RuntimeException)
 {
     ::dbtools::throwFeatureNotImplementedException( "XStatement::executeUpdate", *this );
     return 0;
 
 }
-// -------------------------------------------------------------------------
+
 Any SAL_CALL OCommonStatement::getWarnings(  ) throw(SQLException, RuntimeException)
 {
     ::osl::MutexGuard aGuard( m_aMutex );
@@ -387,9 +387,9 @@ Any SAL_CALL OCommonStatement::getWarnings(  ) throw(SQLException, RuntimeExcept
 
     return makeAny(m_aLastWarning);
 }
-// -------------------------------------------------------------------------
 
-// -------------------------------------------------------------------------
+
+
 void SAL_CALL OCommonStatement::clearWarnings(  ) throw(SQLException, RuntimeException)
 {
     ::osl::MutexGuard aGuard( m_aMutex );
@@ -398,7 +398,7 @@ void SAL_CALL OCommonStatement::clearWarnings(  ) throw(SQLException, RuntimeExc
 
     m_aLastWarning = SQLWarning();
 }
-// -------------------------------------------------------------------------
+
 ::cppu::IPropertyArrayHelper* OCommonStatement::createArrayHelper( ) const
 {
     // this properties are define by the service resultset
@@ -419,12 +419,12 @@ void SAL_CALL OCommonStatement::clearWarnings(  ) throw(SQLException, RuntimeExc
     return new ::cppu::OPropertyArrayHelper(aProps);
 }
 
-// -------------------------------------------------------------------------
+
 ::cppu::IPropertyArrayHelper & OCommonStatement::getInfoHelper()
 {
     return *const_cast<OCommonStatement*>(this)->getArrayHelper();
 }
-// -------------------------------------------------------------------------
+
 sal_Bool OCommonStatement::convertFastPropertyValue(
                             Any & /*rConvertedValue*/,
                             Any & /*rOldValue*/,
@@ -436,7 +436,7 @@ sal_Bool OCommonStatement::convertFastPropertyValue(
     // here we have to try to convert
     return bConverted;
 }
-// -------------------------------------------------------------------------
+
 void OCommonStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& /*rValue*/) throw (Exception)
 {
     // set the value to whatever is necessary
@@ -454,7 +454,7 @@ void OCommonStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const
             ;
     }
 }
-// -------------------------------------------------------------------------
+
 void OCommonStatement::getFastPropertyValue(Any& /*rValue*/,sal_Int32 nHandle) const
 {
     switch(nHandle)
@@ -471,34 +471,34 @@ void OCommonStatement::getFastPropertyValue(Any& /*rValue*/,sal_Int32 nHandle) c
             ;
     }
 }
-// -------------------------------------------------------------------------
+
 IMPLEMENT_SERVICE_INFO(OStatement,"com.sun.star.sdbcx.OStatement","com.sun.star.sdbc.Statement");
-// -----------------------------------------------------------------------------
+
 void SAL_CALL OCommonStatement::acquire() throw()
 {
     OCommonStatement_IBASE::acquire();
 }
-// -----------------------------------------------------------------------------
+
 void SAL_CALL OCommonStatement::release() throw()
 {
     relase_ChildImpl();
 }
-// -----------------------------------------------------------------------------
+
 void SAL_CALL OStatement::acquire() throw()
 {
     OCommonStatement::acquire();
 }
-// -----------------------------------------------------------------------------
+
 void SAL_CALL OStatement::release() throw()
 {
     OCommonStatement::release();
 }
-// -----------------------------------------------------------------------------
+
 Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OCommonStatement::getPropertySetInfo(  ) throw(RuntimeException)
 {
     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 }
-// -----------------------------------------------------------------------------
+
 void OCommonStatement::createColumnMapping()
 {
     SAL_INFO("connectivity.mork", "=>  OCommonStatement::createColumnMapping()" );
@@ -523,7 +523,7 @@ void OCommonStatement::createColumnMapping()
         OSL_TRACE("AFTER  Mapped: %d -> %d", i, m_aColMapping[i] );
 #endif
 }
-// -----------------------------------------------------------------------------
+
 
 void OCommonStatement::analyseSQL()
 {
@@ -549,7 +549,7 @@ void OCommonStatement::analyseSQL()
         }
     }
 }
-//------------------------------------------------------------------
+
 void OCommonStatement::setOrderbyColumn(    OSQLParseNode* pColumnRef,
                                         OSQLParseNode* pAscendingDescending)
 {
@@ -576,6 +576,6 @@ void OCommonStatement::setOrderbyColumn(    OSQLParseNode* pColumnRef,
     // Ascending or Descending?
     m_aOrderbyAscending.push_back((SQL_ISTOKEN(pAscendingDescending,DESC)) ? SQL_DESC : SQL_ASC);
 }
-// -----------------------------------------------------------------------------
+
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MTable.cxx b/connectivity/source/drivers/mork/MTable.cxx
index e90dc3cd0b85..c28d25346fc6 100644
--- a/connectivity/source/drivers/mork/MTable.cxx
+++ b/connectivity/source/drivers/mork/MTable.cxx
@@ -46,7 +46,7 @@ using namespace ::com::sun::star::sdbc;
 using namespace ::com::sun::star::container;
 using namespace ::com::sun::star::lang;
 
-// -------------------------------------------------------------------------
+
 OTable::OTable( sdbcx::OCollection* _pTables, OConnection* _pConnection,
                 const OUString& _Name, const OUString& _Type, const OUString& _Description )
     :OTable_Base(_pTables, _pConnection, sal_True, _Name, _Type, _Description )
@@ -55,25 +55,25 @@ OTable::OTable( sdbcx::OCollection* _pTables, OConnection* _pConnection,
     construct();
 }
 
-//--------------------------------------------------------------------------
+
 sdbcx::OCollection* OTable::createColumns( const TStringVector& _rNames )
 {
     return new OColumns( this, m_aMutex, _rNames );
 }
 
-//--------------------------------------------------------------------------
+
 sdbcx::OCollection* OTable::createKeys(const TStringVector& _rNames)
 {
     return new OKeysHelper( this, m_aMutex, _rNames );
 }
 
-//--------------------------------------------------------------------------
+
 sdbcx::OCollection* OTable::createIndexes(const TStringVector& _rNames)
 {
     return new OIndexesHelper( this, m_aMutex, _rNames );
 }
 
-// -----------------------------------------------------------------------------
+
 
 
 
diff --git a/connectivity/source/drivers/mork/MTables.cxx b/connectivity/source/drivers/mork/MTables.cxx
index 546103ec4c40..19a3f1e25260 100644
--- a/connectivity/source/drivers/mork/MTables.cxx
+++ b/connectivity/source/drivers/mork/MTables.cxx
@@ -70,17 +70,17 @@ sdbcx::ObjectType OTables::createObject(const OUString& _rName)
 
     return xRet;
 }
-// -------------------------------------------------------------------------
+
 void OTables::impl_refresh(  ) throw(RuntimeException)
 {
     static_cast<OCatalog&>(m_rParent).refreshTables();
 }
-// -------------------------------------------------------------------------
+
 void OTables::disposing(void)
 {
 m_xMetaData.clear();
     OCollection::disposing();
 }
-// -----------------------------------------------------------------------------
+
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */