diff --git a/harbour/ChangeLog b/harbour/ChangeLog
index 794f9f9c36..a4f627aad8 100644
--- a/harbour/ChangeLog
+++ b/harbour/ChangeLog
@@ -8,6 +8,36 @@
    2008-12-31 13:59 UTC+0100 Foo Bar <foo.bar@foobar.org>
 */
 
+2008-07-08 07:56 UTC+0200 Viktor Szakats (harbour.01 syenar hu)
+   * contrib/hbodbc/odbc.c
+     ! Fixed all ODBC handles to be pointers. This way it's Win64 
+       compatible. This is an INCOMPATIBLE change. Since normal 
+       app code is using ODBC error values to check for error 
+       conditions, the type of handles shouldn't be a concern for 
+       most app code.
+       I'd ask everyone using hbodbc to do some tests.
+     + TOFIXes added where deprecated (and potentially dangerous) 
+       APIs are used.
+
+   * contrib/hbw32/dllcall.c
+     ! Using hb_parnint()/hb_retnint() instead of hb_parnl()/hb_retnl() 
+       to make Harbour level .dll functions compatible with Win64, and 
+       at the same time stay compatible with XBase++.
+
+   * contrib/rddado/adordd.prg
+     ! Fixed a few places where _SET_EXACT dependent string 
+       comparisons were used. One of them could cause
+       problems updating field values.
+
+   * contrib/hbodbc/todbc.prg
+     * Formatting.
+
+   * contrib/hbodbc/tests/odbcdemo.prg
+   * contrib/hbodbc/tests/odbccall.prg
+   * contrib/hbodbc/tests/testodbc.prg
+     ! Made them work out of the box.
+     ; TOFIX: All of them gives "unrecognized database format" for harbour.mdb.
+
 2008-07-08 02:27 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
   * harbour/source/vm/runner.c
     + added support for passing non string parameters to .HRB INIT/<main>
diff --git a/harbour/contrib/hbodbc/odbc.c b/harbour/contrib/hbodbc/odbc.c
index 18142be294..15393c879b 100644
--- a/harbour/contrib/hbodbc/odbc.c
+++ b/harbour/contrib/hbodbc/odbc.c
@@ -116,16 +116,16 @@ HB_FUNC( SQLALLOCEN ) /* HB_SQLALLOCENV( @hEnv ) --> nRetCode */
    HENV hEnv;
    RETCODE ret = SQLAllocEnv( &hEnv );
 
-   hb_stornl( ( LONG ) hEnv, 1 );
+   hb_storptr( hEnv, 1 );
    hb_retni( ret );
 }
 
 HB_FUNC( SQLALLOCCO ) /* HB_SQLALLOCCONNECT( hEnv, @ hDbc ) --> nRetCode */
 {
    HDBC hDbc;
-   RETCODE ret = SQLAllocConnect( ( HENV ) hb_parnl( 1 ), &hDbc );
+   RETCODE ret = SQLAllocConnect( ( HENV ) hb_parptr( 1 ), &hDbc );
 
-   hb_stornl( ( LONG ) hDbc, 2 );
+   hb_storptr( hDbc, 2 );
    hb_retni( ret );
 }
 
@@ -139,11 +139,14 @@ HB_FUNC( SQLDRIVERC ) /* HB_SQLDRIVERCONNECT( hDbc, @ cConnectString ) --> nRetC
    LPTSTR lpStr = HB_TCHAR_CONVTO( hb_parcx( 2 ) );
    TCHAR buffer[ 1024 ];
    buffer[ 0 ] = '\0';
-   ret =  SQLDriverConnect( ( HDBC ) hb_parnl( 1 ),
-                            GetDesktopWindow(),
-                            lpStr, ( SQLSMALLINT ) hb_parclen( 2 ),
-                            buffer, sizeof( buffer ), &wLen,
-                            SQL_DRIVER_COMPLETE );
+   ret = SQLDriverConnect( ( HDBC ) hb_parptr( 1 ),
+                           GetDesktopWindow(),
+                           lpStr,
+                           ( SQLSMALLINT ) hb_parclen( 2 ),
+                           buffer,
+                           sizeof( buffer ),
+                           &wLen,
+                           SQL_DRIVER_COMPLETE );
    HB_TCHAR_FREE( lpStr );
    if( ISBYREF( 3 ) )
    {
@@ -154,10 +157,14 @@ HB_FUNC( SQLDRIVERC ) /* HB_SQLDRIVERCONNECT( hDbc, @ cConnectString ) --> nRetC
 #else
    BYTE buffer[ 1024 ];
    buffer[ 0 ] = '\0';
-   ret =  SQLDriverConnect( ( HDBC ) hb_parnl( 1 ),
-                            0, ( SQLCHAR * ) hb_parcx( 2 ), ( SQLSMALLINT ) hb_parclen( 2 ),
-                            buffer, sizeof( buffer ), &wLen,
-                            SQL_DRIVER_COMPLETE );
+   ret = SQLDriverConnect( ( HDBC ) hb_parptr( 1 ),
+                           0,
+                           ( SQLCHAR * ) hb_parcx( 2 ),
+                           ( SQLSMALLINT ) hb_parclen( 2 ),
+                           buffer,
+                           sizeof( buffer ),
+                           &wLen,
+                           SQL_DRIVER_COMPLETE );
    hb_storc( ( char * ) buffer, 3 );
 #endif
    hb_retni( ret );
@@ -171,7 +178,7 @@ HB_FUNC( SQLCONNECT ) /* HB_SQLCONNECT( hDbc, cDSN, cUseName, cPassword ) --> nR
           lpUseName  = HB_TCHAR_CONVTO( hb_parcx( 3 ) ),
           lpPassword = HB_TCHAR_CONVTO( hb_parcx( 4 ) );
 
-   ret =  SQLConnect( ( HDBC ) hb_parnl( 1 ),
+   ret =  SQLConnect( ( HDBC ) hb_parptr( 1 ),
                       lpDSN,
                       hb_parclen( 2 ),
                       lpUseName,
@@ -183,7 +190,7 @@ HB_FUNC( SQLCONNECT ) /* HB_SQLCONNECT( hDbc, cDSN, cUseName, cPassword ) --> nR
    HB_TCHAR_FREE( lpUseName );
    HB_TCHAR_FREE( lpPassword );
 #else
-   ret =  SQLConnect( ( HDBC ) hb_parnl( 1 ),
+   ret =  SQLConnect( ( HDBC ) hb_parptr( 1 ),
                       (unsigned char*) hb_parcx( 2 ),
                       ( SQLSMALLINT ) hb_parclen( 2 ),
                       (unsigned char*) hb_parcx( 3 ),
@@ -196,46 +203,46 @@ HB_FUNC( SQLCONNECT ) /* HB_SQLCONNECT( hDbc, cDSN, cUseName, cPassword ) --> nR
 
 HB_FUNC( SQLDISCONN )  /* HB_SQLDISCONNECT( hDbc ) --> nRetCode */
 {
-   hb_retni( SQLDisconnect( ( HDBC ) hb_parnl( 1 ) ) );
+   hb_retni( SQLDisconnect( ( HDBC ) hb_parptr( 1 ) ) );
 }
 
 HB_FUNC( SQLFREECON )  /* HB_SQLFREECONNECT( hDbc ) --> nRetCode */
 {
-   hb_retni( SQLFreeConnect( ( HDBC ) hb_parnl( 1 ) ) );
+   hb_retni( SQLFreeConnect( ( HDBC ) hb_parptr( 1 ) ) );
 }
 
 HB_FUNC( SQLFREEENV )  /* HB_SQLFREEENV( hEnv ) --> nRetCode */
 {
-   hb_retni( SQLFreeEnv( ( HENV ) hb_parnl( 1 ) ) );
+   hb_retni( SQLFreeEnv( ( HENV ) hb_parptr( 1 ) ) );
 }
 
-HB_FUNC( SQLALLOCST )  /* HB_SQLALLOCSTMT( hDbc, @ hStmt ) --> nRetCode */
+HB_FUNC( SQLALLOCST )  /* HB_SQLALLOCSTMT( hDbc, @hStmt ) --> nRetCode */
 {
    HSTMT hStmt;
 
-   hb_retni( SQLAllocStmt( ( HDBC ) hb_parnl( 1 ), &hStmt ) );
-   hb_stornl( ( LONG ) hStmt, 2 );
+   hb_retni( SQLAllocStmt( ( HDBC ) hb_parptr( 1 ), &hStmt ) );
+   hb_storptr( hStmt, 2 );
 }
 
 HB_FUNC( SQLFREESTM ) /* HB_SQLFREESTMT( hStmt, nType ) --> nRetCode */
 {
-   hb_retni( SQLFreeStmt( ( HSTMT ) hb_parnl( 1 ), hb_parni( 2 ) ) );
+   hb_retni( SQLFreeStmt( ( HSTMT ) hb_parptr( 1 ), hb_parni( 2 ) ) );
 }
 
 HB_FUNC( SQLEXECDIR )  /* HB_SQLEXECDIRECT( hStmt, cStatement ) --> nRetCode */
 {
 #if defined( HB_OS_WIN_32 ) && defined( UNICODE )
    LPTSTR lpStr = HB_TCHAR_CONVTO( hb_parcx( 2 ) );
-   hb_retni( SQLExecDirect( ( HSTMT ) hb_parnl( 1 ), lpStr, hb_parclen( 2 ) ) );
+   hb_retni( SQLExecDirect( ( HSTMT ) hb_parptr( 1 ), lpStr, hb_parclen( 2 ) ) );
    HB_TCHAR_FREE( lpStr );
 #else
-   hb_retni( SQLExecDirect( ( HSTMT ) hb_parnl( 1 ), (unsigned char*) hb_parcx( 2 ), hb_parclen( 2 ) ) );
+   hb_retni( SQLExecDirect( ( HSTMT ) hb_parptr( 1 ), (unsigned char*) hb_parcx( 2 ), hb_parclen( 2 ) ) );
 #endif
 }
 
 HB_FUNC( SQLFETCH )   /* HB_SQLFETCH( hStmt ) --> nRetCode */
 {
-   hb_retni( SQLFetch( ( HSTMT ) hb_parnl( 1 ) ) );
+   hb_retni( SQLFetch( ( HSTMT ) hb_parptr( 1 ) ) );
 }
 
 HB_FUNC( SQLGETDATA ) /* HB_SQLGETDATA( hStmt, nField, nType, nLen, @cBuffer ) --> nRetCode */
@@ -259,7 +266,7 @@ HB_FUNC( SQLGETDATA ) /* HB_SQLGETDATA( hStmt, nField, nType, nLen, @cBuffer ) -
    wResult = ! SQL_NO_DATA;
    while( wResult != SQL_NO_DATA )
    {
-      wResult = SQLGetData( ( HSTMT ) hb_parnl( 1 ), hb_parni( 2 ), wType, ( PTR ) bBuffer, lLen, &lLen );
+      wResult = SQLGetData( ( HSTMT ) hb_parptr( 1 ), hb_parni( 2 ), wType, ( PTR ) bBuffer, lLen, &lLen );
       if( wResult == SQL_SUCCESS && iReallocs == 0 )
       {
          hb_storclen( ( LPSTR ) bBuffer, ( ULONG ) ( lLen < 0 ? 0 : ( lLen < hb_parnl( 4 ) ? lLen : hb_parnl( 4 ) ) ), 5 );
@@ -307,45 +314,45 @@ HB_FUNC( SQLGETDATA ) /* HB_SQLGETDATA( hStmt, nField, nType, nLen, @cBuffer ) -
 /* HB_NUMRESULTCOLS( hStmt, @nColCount ) */
 HB_FUNC( SQLNUMRES )
 {
-    SQLSMALLINT nCols;
-    WORD wResult = SQLNumResultCols( ( HSTMT ) hb_parnl( 1 ), &nCols );
+   SQLSMALLINT nCols;
+   WORD wResult = SQLNumResultCols( ( HSTMT ) hb_parptr( 1 ), &nCols );
 
 /* if( wResult == SQL_SUCCESS || wResult == SQL_SUCCESS_WITH_INFO ) */
       hb_stornl( ( LONG ) nCols, 2 );
 
-    hb_retni( wResult );
+   hb_retni( wResult );
 }
 
 /* HB_SQLDESCRIBECOL( hStmt, nCol, @cName, nLen, @nBufferLen, @nDataType, @nColSize, @nDec, @nNull ) --> nRetCode */
 HB_FUNC( SQLDESCRIB )
 {
-    SDWORD      lLen      = ( SDWORD ) hb_parnl( 4 );
-    SQLSMALLINT wBufLen   = hb_parni( 5 );
-    SQLSMALLINT wDataType = hb_parni( 6 );
-    SQLULEN     wColSize  = hb_parni( 7 );
-    SQLSMALLINT wDecimals = hb_parni( 8 );
-    SQLSMALLINT wNullable = hb_parni( 9 );
+   SDWORD      lLen      = ( SDWORD ) hb_parnl( 4 );
+   SQLSMALLINT wBufLen   = hb_parni( 5 );
+   SQLSMALLINT wDataType = hb_parni( 6 );
+   SQLULEN     wColSize  = hb_parni( 7 );
+   SQLSMALLINT wDecimals = hb_parni( 8 );
+   SQLSMALLINT wNullable = hb_parni( 9 );
 #if defined( HB_OS_WIN_32 ) && defined( UNICODE )
-    LPTSTR      buffer    = ( LPTSTR ) hb_xgrab( lLen * sizeof( TCHAR ) );
+   LPTSTR      buffer    = ( LPTSTR ) hb_xgrab( lLen * sizeof( TCHAR ) );
 #else
-    SQLCHAR *   buffer    = ( SQLCHAR * ) hb_xgrab( lLen * sizeof( SQLCHAR ) );
+   SQLCHAR *   buffer    = ( SQLCHAR * ) hb_xgrab( lLen * sizeof( SQLCHAR ) );
 #endif
-    WORD        wResult;
+   WORD        wResult;
 
-    wResult = SQLDescribeCol( ( HSTMT ) hb_parnl( 1 ),
-                              hb_parni( 2 ),
-                              buffer,
-                              ( SQLSMALLINT ) lLen,
-                              &wBufLen,
-                              &wDataType, 
-                              &wColSize,
-                              &wDecimals,
-                              &wNullable );
+   wResult = SQLDescribeCol( ( HSTMT ) hb_parptr( 1 ),
+                             hb_parni( 2 ),
+                             buffer,
+                             ( SQLSMALLINT ) lLen,
+                             &wBufLen,
+                             &wDataType, 
+                             &wColSize,
+                             &wDecimals,
+                             &wNullable );
 
-    if( wResult == SQL_SUCCESS || wResult == SQL_SUCCESS_WITH_INFO )
-    {
-       if( ISBYREF( 3 ) )
-       {
+   if( wResult == SQL_SUCCESS || wResult == SQL_SUCCESS_WITH_INFO )
+   {
+      if( ISBYREF( 3 ) )
+      {
 #if defined( HB_OS_WIN_32 ) && defined( UNICODE )
          char * szStr = HB_TCHAR_CONVFROM( buffer );
          hb_storc( szStr, 3 );
@@ -353,69 +360,74 @@ HB_FUNC( SQLDESCRIB )
 #else
          hb_storclen( ( char * ) buffer, ( WORD ) wBufLen, 3 );
 #endif
-       }
-       hb_stornl( ( LONG ) wBufLen, 5 );
-       hb_stornl( ( LONG ) wDataType, 6 );
-       hb_stornl( ( LONG ) wColSize, 7 );
-       hb_stornl( ( LONG ) wDecimals, 8 );
-       hb_stornl( ( LONG ) wNullable, 9 );
-    }
+      }
+      hb_stornl( ( LONG ) wBufLen, 5 );
+      hb_stornl( ( LONG ) wDataType, 6 );
+      hb_stornl( ( LONG ) wColSize, 7 );
+      hb_stornl( ( LONG ) wDecimals, 8 );
+      hb_stornl( ( LONG ) wNullable, 9 );
+   }
 
-    hb_xfree( buffer );
-    hb_retni( wResult );
+   hb_xfree( buffer );
+   hb_retni( wResult );
 }
 
 /* SQLCOLATTRIBUTE( hStmt, nCol, nField, @cName, nLen, @nBufferLen, @nAttribute ) --> nRetCode */
 HB_FUNC( SQLCOLATTRIBUTE )
 {
-    SDWORD      lLen      = ( SDWORD ) hb_parnl( 5 );
-    PTR         bBuffer   = hb_xgrab( lLen );
-    SQLSMALLINT wBufLen   = hb_parni( 6 );
+   SDWORD      lLen      = ( SDWORD ) hb_parnl( 5 );
+   PTR         bBuffer   = hb_xgrab( lLen );
+   SQLSMALLINT wBufLen   = hb_parni( 6 );
 #if defined(__DMC__)
-    SQLINTEGER  wNumPtr   = hb_parni( 7 );
+   SQLINTEGER  wNumPtr   = hb_parni( 7 );
 #else
-    SQLLEN      wNumPtr   = hb_parni( 7 );
+   SQLLEN      wNumPtr   = hb_parni( 7 );
 #endif
-    WORD        wResult   = SQLColAttribute( ( HSTMT ) hb_parnl( 1 ), hb_parni( 2 ), hb_parni( 3 ),
-                                             (unsigned char*) bBuffer, hb_parni( 5 ), &wBufLen,
-                                             &wNumPtr );
+   WORD        wResult   = SQLColAttribute( ( HSTMT ) hb_parptr( 1 ),
+                                            hb_parni( 2 ),
+                                            hb_parni( 3 ),
+                                            (unsigned char*) bBuffer, 
+                                            hb_parni( 5 ), 
+                                            &wBufLen,
+                                            &wNumPtr );
 
-    if( wResult == SQL_SUCCESS || wResult == SQL_SUCCESS_WITH_INFO )
-    {
-       hb_storclen( ( LPSTR ) bBuffer,
-                    ( WORD ) wBufLen, 4 );
-       hb_stornl( ( LONG ) wBufLen, 6 );
-       hb_stornl( ( LONG ) wNumPtr, 7 );
-    }
+   if( wResult == SQL_SUCCESS || wResult == SQL_SUCCESS_WITH_INFO )
+   {
+      hb_storclen( ( LPSTR ) bBuffer,
+                   ( WORD ) wBufLen, 4 );
+      hb_stornl( ( LONG ) wBufLen, 6 );
+      hb_stornl( ( LONG ) wNumPtr, 7 );
+   }
 
-    hb_xfree( ( PTR ) bBuffer );
-    hb_retni( wResult );
+   hb_xfree( ( PTR ) bBuffer );
+   hb_retni( wResult );
 }
 
 /* HB_SQLEXTENDEDFETCH( hStmt, nOrientation, nOffset, @nRows, @nRowStatus ) */
 HB_FUNC( SQLEXTENDE )
 {
-    SQLULEN      uiRowCountPtr = hb_parni( 4 );
-    SQLUSMALLINT siRowStatus   = hb_parni( 5 );
-    WORD         wResult       = SQLExtendedFetch( ( HSTMT ) hb_parnl( 1 ),
-                                                   ( USHORT )hb_parnl( 2 ),
-                                                   ( USHORT )hb_parnl( 3 ),
-                                                   &uiRowCountPtr,
-                                                   &siRowStatus );
+   SQLULEN      uiRowCountPtr = hb_parni( 4 );
+   SQLUSMALLINT siRowStatus   = hb_parni( 5 );
+   WORD         wResult       = SQLExtendedFetch( ( HSTMT ) hb_parptr( 1 ),
+                                                  ( USHORT ) hb_parnl( 2 ),
+                                                  ( USHORT ) hb_parnl( 3 ),
+                                                  &uiRowCountPtr,
+                                                  &siRowStatus );
 
-    if( wResult == SQL_SUCCESS || wResult == SQL_SUCCESS_WITH_INFO )
-    {
-       hb_stornl( ( LONG ) uiRowCountPtr, 4 );
-       hb_stornl( ( LONG ) siRowStatus, 5 );
-    }
+   if( wResult == SQL_SUCCESS || wResult == SQL_SUCCESS_WITH_INFO )
+   {
+      hb_stornl( ( LONG ) uiRowCountPtr, 4 );
+      hb_stornl( ( LONG ) siRowStatus, 5 );
+   }
 
-    hb_retni( wResult );
+   hb_retni( wResult );
 }
 
 HB_FUNC( SQLFETCHSC )
 {
-    hb_retni( SQLFetchScroll( ( HSTMT ) hb_parnl( 1 ),
-                              ( SHORT ) hb_parnl( 2 ), hb_parnl( 3 ) ) );
+   hb_retni( SQLFetchScroll( ( HSTMT ) hb_parptr( 1 ),
+                             ( SHORT ) hb_parnl( 2 ),
+                             hb_parnl( 3 ) ) );
 }
 
 HB_FUNC( SQLERROR ) /* hEnv, hDbc, hStmt, @ cErrorClass, @ nType, @ cErrorMsg */
@@ -427,9 +439,14 @@ HB_FUNC( SQLERROR ) /* hEnv, hDbc, hStmt, @ cErrorClass, @ nType, @ cErrorMsg */
 #else
    BYTE       buffer[ 256 ], szErrorMsg[ 256 ];
 #endif
-   hb_retni( SQLError( ( HENV ) hb_parnl( 1 ), ( HDBC ) hb_parnl( 2 ),
-                       ( HSTMT ) hb_parnl( 3 ), buffer, &lError,
-                       szErrorMsg, sizeof( szErrorMsg ), &wLen ) );
+   hb_retni( SQLError( ( HENV ) hb_parptr( 1 ),
+                       ( HDBC ) hb_parptr( 2 ),
+                       ( HSTMT ) hb_parnl( 3 ),
+                       buffer,
+                       &lError,
+                       szErrorMsg,
+                       sizeof( szErrorMsg ),
+                       &wLen ) );
 
    if( ISBYREF( 4 ) )
    {
@@ -457,7 +474,7 @@ HB_FUNC( SQLERROR ) /* hEnv, hDbc, hStmt, @ cErrorClass, @ nType, @ cErrorMsg */
 HB_FUNC( SQLROWCOUN )
 {
     SQLLEN  iRowCountPtr = hb_parni( 2 );
-    WORD    wResult      = SQLRowCount( ( HSTMT ) hb_parnl( 1 ),
+    WORD    wResult      = SQLRowCount( ( HSTMT ) hb_parptr( 1 ),
                                         &iRowCountPtr );
     if( wResult == SQL_SUCCESS || wResult == SQL_SUCCESS_WITH_INFO )
     {
@@ -471,30 +488,39 @@ HB_FUNC( SQLGETINFO ) /* hDbc, nType, @cResult */
 {
    BYTE bBuffer[ 512 ];
    SQLSMALLINT wLen;
-   WORD wResult = SQLGetInfo( ( HDBC ) hb_parnl( 1 ), ( UWORD ) hb_parnl( 2 ), bBuffer, sizeof( bBuffer ), &wLen );
+   WORD wResult = SQLGetInfo( ( HDBC ) hb_parptr( 1 ),
+                              ( UWORD ) hb_parnl( 2 ), 
+                              bBuffer,
+                              sizeof( bBuffer ),
+                              &wLen );
 
-   hb_storclen( (char *) bBuffer, wLen, 3 );
+   hb_storclen( ( char * ) bBuffer, wLen, 3 );
    hb_retni( wResult );
 }
 
 HB_FUNC( SQLSETCONNECTOPTION ) /* hDbc, nOption, uOption */
 {
-   hb_retnl( ( LONG ) SQLSetConnectOption( ( HDBC ) hb_parnl( 1 ), ( UWORD ) hb_parnl( 2 ),
-           ( UDWORD ) ISCHAR( 3 ) ? ( LONG ) hb_parcx( 3 ) : hb_parnl( 3 ) ) );
+   /* TOFIX: SQLSetConnectOption() deprecated. */
+   hb_retnl( ( LONG ) SQLSetConnectOption( ( HDBC ) hb_parptr( 1 ),
+             ( UWORD ) hb_parnl( 2 ),
+             ( UDWORD ) ISCHAR( 3 ) ? ( LONG ) hb_parcx( 3 ) : hb_parnl( 3 ) ) );
 }
 
 HB_FUNC( SQLSETSTMTOPTION ) /* hStmt, nOption, uOption )  --> nRetCode */
 {
-   hb_retnl( ( LONG ) SQLSetStmtOption( ( SQLHSTMT ) hb_parnl( 1 ), ( UWORD ) hb_parnl( 2 ),
-           ( UDWORD ) ISCHAR( 3 ) ? ( LONG ) hb_parcx( 3 ) : hb_parnl( 3 ) ) );
+   /* TOFIX: SQLSetStmtOption() deprecated. */
+   hb_retnl( ( LONG ) SQLSetStmtOption( ( SQLHSTMT ) hb_parptr( 1 ),
+             ( UWORD ) hb_parnl( 2 ),
+             ( UDWORD ) ISCHAR( 3 ) ? ( LONG ) hb_parcx( 3 ) : hb_parnl( 3 ) ) );
 }
 
 HB_FUNC( SQLGETCONNECTOPTION ) /* hDbc, nOption, @cOption */
 {
    BYTE bBuffer[ 512 ];
-   WORD wResult = SQLGetConnectOption( ( HDBC ) hb_parnl( 1 ), hb_parni( 2 ), bBuffer );
+   /* TOFIX: SQLGetConnectOption() deprecated. */
+   WORD wResult = SQLGetConnectOption( ( HDBC ) hb_parptr( 1 ), hb_parni( 2 ), bBuffer );
    if( wResult == SQL_SUCCESS )
-      hb_storclen( (char *) bBuffer, sizeof( bBuffer ), 3 );
+      hb_storclen( ( char * ) bBuffer, sizeof( bBuffer ), 3 );
 
    hb_retni( wResult );
 }
@@ -502,44 +528,44 @@ HB_FUNC( SQLGETCONNECTOPTION ) /* hDbc, nOption, @cOption */
 HB_FUNC( SQLGETSTMTOPTION ) /* hStmt, nOption, @cOption */
 {
    BYTE bBuffer[ 512 ];
-   WORD wResult = SQLGetStmtOption( ( SQLHSTMT ) hb_parnl( 1 ), hb_parni( 2 ), bBuffer );
+   /* TOFIX: SQLGetStmtOption() deprecated. */
+   WORD wResult = SQLGetStmtOption( ( SQLHSTMT ) hb_parptr( 1 ), hb_parni( 2 ), bBuffer );
 
    if( wResult == SQL_SUCCESS )
-   {
-      hb_storclen( (char *) bBuffer, sizeof( bBuffer ), 3 );
-   }
+      hb_storclen( ( char * ) bBuffer, sizeof( bBuffer ), 3 );
 
    hb_retni( wResult );
 }
 
 HB_FUNC( SQLCOMMIT ) /* hEnv, hDbc */
 {
-   hb_retni( SQLTransact( ( HENV ) hb_parnl( 1 ), ( HDBC ) hb_parnl( 2 ), SQL_COMMIT ) );
+   hb_retni( SQLTransact( ( HENV ) hb_parptr( 1 ), ( HDBC ) hb_parptr( 2 ), SQL_COMMIT ) );
 }
 
 HB_FUNC( SQLROLLBACK )  /* hEnv, hDbc */
 {
-   hb_retni( SQLTransact( ( HENV ) hb_parnl( 1 ), ( HDBC ) hb_parnl( 2 ), SQL_ROLLBACK ) );
+   hb_retni( SQLTransact( ( HENV ) hb_parptr( 1 ), ( HDBC ) hb_parptr( 2 ), SQL_ROLLBACK ) );
 }
+
 HB_FUNC( SETNUMLEN )  /* SETNUMLEN( nValue, nSize, nDecimals ) ==> nValue (nSize, nDec) */
 {
-   hb_retnlen( hb_parnd( 1 ), hb_parnl( 2 ), hb_parnl( 3 ) );
+   hb_retnlen( hb_parnd( 1 ), hb_parni( 2 ), hb_parni( 3 ) );
 }
 
 HB_FUNC( SQLPREPARE )  /* HB_SQLPREPARE( hStmt, cStatement ) --> nRetCode */
 {
 #if defined( HB_OS_WIN_32 ) && defined( UNICODE )
    LPTSTR lpStr = HB_TCHAR_CONVTO( hb_parcx( 2 ) );
-   hb_retni( SQLPrepare( ( HSTMT ) hb_parnl( 1 ), lpStr, SQL_NTS ) );
+   hb_retni( SQLPrepare( ( HSTMT ) hb_parptr( 1 ), lpStr, SQL_NTS ) );
    HB_TCHAR_FREE( lpStr );
 #else
-   hb_retni( SQLPrepare( ( HSTMT ) hb_parnl( 1 ), (unsigned char*) hb_parcx( 2 ), SQL_NTS ) );
+   hb_retni( SQLPrepare( ( HSTMT ) hb_parptr( 1 ), (unsigned char*) hb_parcx( 2 ), SQL_NTS ) );
 #endif
 }
 
 HB_FUNC( SQLEXECUTE )  /* HB_SQLEXECUTE( hStmt ) --> nRetCode */
 {
-   hb_retni( SQLExecute( ( HSTMT ) hb_parnl( 1 ) ) );
+   hb_retni( SQLExecute( ( HSTMT ) hb_parptr( 1 ) ) );
 }
 
 HB_FUNC( SQLEXECUTESCALAR )
@@ -549,7 +575,7 @@ HB_FUNC( SQLEXECUTESCALAR )
    BYTE bBuffer[ 256 ];
    SWORD wResult;
 
-   wResult = SQLAllocStmt( ( HDBC ) hb_parnl( 2 ), &hStmt );
+   wResult = SQLAllocStmt( ( HDBC ) hb_parptr( 2 ), &hStmt );
 
    if( wResult == SQL_SUCCESS || wResult == SQL_SUCCESS_WITH_INFO )
    {
@@ -603,19 +629,24 @@ HB_FUNC( SQLSTOD )
 
 HB_FUNC( SQLMORERESULTS ) /* hEnv, hDbc */
 {
-   hb_retni( SQLMoreResults( ( SQLHSTMT ) hb_parnl( 1 ) ) );
+   hb_retni( SQLMoreResults( ( SQLHSTMT ) hb_parptr( 1 ) ) );
 }
 
 #if 0
 HB_FUNC( SQLBINDOUTPARAM ) /* SqlBindOutParam( nStatementHandle, nParameterNumber, nParameterType, ColumnSize, DecimalDigits, @ParamValue, @ParamLength    ) --> nRetCode */
 {
-   SQLLEN lLen      = hb_parnl( 7 );
+   SQLLEN lLen = hb_parnl( 7 );
    RETCODE ret;
 
-   ret = SQLBindParameter( ( HSTMT ) hb_parnl( 1 ), (USHORT) hb_parni( 2 ),
-                           SQL_PARAM_OUTPUT, SQL_CHAR, (USHORT) hb_parni( 3 ),
-                           (USHORT) hb_parni( 4 ), (USHORT) hb_parni( 5 ),
-                           hb_parcx( 6 ), hb_parclen( 6 ),
+   ret = SQLBindParameter( ( HSTMT ) hb_parptr( 1 ),
+                           ( USHORT ) hb_parni( 2 ),
+                           SQL_PARAM_OUTPUT,
+                           SQL_CHAR,
+                           ( USHORT ) hb_parni( 3 ),
+                           ( USHORT ) hb_parni( 4 ),
+                           ( USHORT ) hb_parni( 5 ),
+                           hb_parcx( 6 ),
+                           hb_parclen( 6 ),
                            &lLen );
    hb_stornl( ( LONG ) lLen, 7 );
    hb_retni( ret );
diff --git a/harbour/contrib/hbodbc/tests/odbccall.prg b/harbour/contrib/hbodbc/tests/odbccall.prg
index 354fdf87a0..391349db0e 100644
--- a/harbour/contrib/hbodbc/tests/odbccall.prg
+++ b/harbour/contrib/hbodbc/tests/odbccall.prg
@@ -7,12 +7,15 @@
 
 FUNCTION Main()
 
-   LOCAL cExePath  := substr( hb_argv(0), 1, rat( "\", hb_argv(0) ) - 1 )
-   LOCAL cConStr   := ;
-      "DBQ=" + cExePath + "\harbour.mdb;" + ;
-      "Driver={Microsoft Access Driver (*.mdb)}"
+   LOCAL cConStr
+   LOCAL cDir
+   LOCAL dsFunctions
 
-   LOCAL dsFunctions := TODBC():New( "xx" ) // cConStr )
+   hb_FNameSplit( hb_ArgV( 0 ), @cDir )
+
+   cConStr := "DBQ=" + hb_FNameMerge( cDir, "harbour.mdb" ) + ";Driver={Microsoft Access Driver (*.mdb)}"
+
+   dsFunctions := TODBC():New( cConStr )
 
    WITH dsFunctions DO
 
diff --git a/harbour/contrib/hbodbc/tests/odbcdemo.prg b/harbour/contrib/hbodbc/tests/odbcdemo.prg
index 0d7b59ea37..dcb0b4b618 100644
--- a/harbour/contrib/hbodbc/tests/odbcdemo.prg
+++ b/harbour/contrib/hbodbc/tests/odbcdemo.prg
@@ -13,15 +13,16 @@ FUNCTION Main()
    LOCAL aOrders
    LOCAL nOp
    LOCAL dsFunctions
+   LOCAL cConStr
+   LOCAL cDir
 
-//   LOCAL cExePath := substr( cargv(), 1, rat( "\", cargv() ) - 1 )
-   LOCAL cConStr  := ;
-           "DBQ=" + "harbour.mdb;" + ;
-           "Driver={Microsoft Access Driver (*.mdb)}"
+   hb_FNameSplit( hb_ArgV( 0 ), @cDir )
+
+   cConStr := "DBQ=" + hb_FNameMerge( cDir, "harbour.mdb" ) + ";Driver={Microsoft Access Driver (*.mdb)}"
 
    dsFunctions := TODBC():New( cConStr )
 
-   set COLOR TO "W+/B"
+   SET COLOR TO "W+/B"
    CLS
 
    WHILE .T.
diff --git a/harbour/contrib/hbodbc/tests/testodbc.prg b/harbour/contrib/hbodbc/tests/testodbc.prg
index 3fae498691..7f326a7fc4 100644
--- a/harbour/contrib/hbodbc/tests/testodbc.prg
+++ b/harbour/contrib/hbodbc/tests/testodbc.prg
@@ -10,48 +10,51 @@
 
 FUNCTION Main()
 
-  LOCAL hEnv       := 0
-  LOCAL hDbc       := 0
-  LOCAL hStmt      := 0
-  LOCAL cConstrin  := "DBQ=" + GetEnv( "HARBOUR_DIR" ) + ;
-    "\source\odbc\harbour.mdb;Driver={Microsoft Access Driver (*.mdb)}"
-  LOCAL cConstrout := SPACE(1024)
-  LOCAL nRows      := 0
-  LOCAL cCode, cFunc, cState, cComm
-
-  ? padc( "*** ODBC ACCESS TEST ***", 80 )
-  ?
-  ? "Allocating environment... "
-  SQLAllocEn( @hEnv )
-  ? "Allocating connection... "
-  SQLAllocCo( hEnv, @hDbc )
-  ? "Connecting to driver " + cConstrin + "... "
-  SQLDriverC( hDbc, cConstrin, @cConstrout )
-  ? "Allocating statement... "
-  SQLAllocSt( hDbc, @hStmt )
-
-  ?
-  ? "SQL: SELECT * FROM FUNCTIONS"
-  SQLExecDir( hStmt, "select * from functions" )
-
-  ?
-
-  WHILE SQLFetch( hStmt ) == 0
-     nRows++
-     GET ROW 1 INTO cCode
-     GET ROW 2 INTO cFunc
-     GET ROW 3 INTO cState
-     GET ROW 4 INTO cComm
-     ? cCode, padr( cFunc, 20 ), cState, cComm
-  ENDDO
-
-  ? "------------------------------------------------------------------------------"
-  ? str( nRows, 4 ), " row(s) affected."
-
-  SQLFreeStm( hStmt, SQL_DROP )
-  SQLDisconn( hDbc )
-  SQLFreeCon( hDbc )
-  SQLFreeEnv( hEnv )
-
-  RETURN( NIL )
-
+   LOCAL hEnv       := 0
+   LOCAL hDbc       := 0
+   LOCAL hStmt      := 0
+   LOCAL cConstrin
+   LOCAL cConstrout := SPACE(1024)
+   LOCAL nRows      := 0
+   LOCAL cCode, cFunc, cState, cComm
+   LOCAL cDir
+  
+   hb_FNameSplit( hb_ArgV( 0 ), @cDir )
+   
+   cConstrin := "DBQ=" + hb_FNameMerge( cDir, "harbour.mdb" ) + ";Driver={Microsoft Access Driver (*.mdb)}"
+  
+   ? padc( "*** ODBC ACCESS TEST ***", 80 )
+   ?
+   ? "Allocating environment... "
+   SQLAllocEn( @hEnv )
+   ? "Allocating connection... "
+   SQLAllocCo( hEnv, @hDbc )
+   ? "Connecting to driver " + cConstrin + "... "
+   SQLDriverC( hDbc, cConstrin, @cConstrout )
+   ? "Allocating statement... "
+   SQLAllocSt( hDbc, @hStmt )
+  
+   ?
+   ? "SQL: SELECT * FROM FUNCTIONS"
+   SQLExecDir( hStmt, "select * from functions" )
+  
+   ?
+  
+   WHILE SQLFetch( hStmt ) == 0
+      nRows++
+      GET ROW 1 INTO cCode
+      GET ROW 2 INTO cFunc
+      GET ROW 3 INTO cState
+      GET ROW 4 INTO cComm
+      ? cCode, padr( cFunc, 20 ), cState, cComm
+   ENDDO
+  
+   ? "------------------------------------------------------------------------------"
+   ? str( nRows, 4 ), " row(s) affected."
+  
+   SQLFreeStm( hStmt, SQL_DROP )
+   SQLDisconn( hDbc )
+   SQLFreeCon( hDbc )
+   SQLFreeEnv( hEnv )
+  
+   RETURN NIL
diff --git a/harbour/contrib/hbodbc/todbc.prg b/harbour/contrib/hbodbc/todbc.prg
index 96df1bfd12..7026b5202b 100644
--- a/harbour/contrib/hbodbc/todbc.prg
+++ b/harbour/contrib/hbodbc/todbc.prg
@@ -103,10 +103,10 @@ METHOD New() CLASS TODBCField
    ::DataType  := - 1
    ::DataSize  := - 1
    ::DataDecs  := - 1
-   ::AllowNull := .f.
+   ::AllowNull := .F.
    ::Value     := NIL
 
-RETURN ( Self )
+RETURN Self
 
 *+--------------------------------------------------------------------
 *+
@@ -182,7 +182,7 @@ METHOD SQLErrorMessage() CLASS TODBC
 
    SQLError( ::hEnv, ::hDbc, ::hStmt, @cErrorClass, @nType, @cErrorMsg )
 
-RETURN( "Error " + cErrorClass + " - " + cErrorMsg )
+RETURN "Error " + cErrorClass + " - " + cErrorMsg
 
 /*-----------------------------------------------------------------------*/
 
@@ -198,7 +198,7 @@ METHOD New( cODBCStr, cUserName, cPassword, lCache ) CLASS TODBC
    DEFAULT lCache TO .T.
 
    ::cODBCStr  := cODBCStr
-   ::Active    := .f.
+   ::Active    := .F.
    ::Fields    := {}
    ::nEof      := 0
    ::lBof      := .F.
@@ -229,7 +229,7 @@ METHOD New( cODBCStr, cUserName, cPassword, lCache ) CLASS TODBC
       ENDIF
    ENDIF
 
-RETURN ( Self )
+RETURN Self
 
 /*-----------------------------------------------------------------------*/
 
@@ -254,7 +254,7 @@ METHOD Destroy() CLASS TODBC
    SQLFreeCon( ::hDbc )                        // Frees the connection
    SQLFreeEnv( ::hEnv )                        // Frees the environment
 
-RETURN ( NIL )
+RETURN NIL
 
 /*-----------------------------------------------------------------------*/
 
@@ -269,19 +269,19 @@ return cBuffer
 
 METHOD SetCnnOptions( nType, uBuffer ) CLASS TODBC
 
-return ( ::nRetCode := SQLSetConnectOption( ::hDbc, nType, uBuffer ) )
+return ::nRetCode := SQLSetConnectOption( ::hDbc, nType, uBuffer )
 
 /*-----------------------------------------------------------------------*/
 
 METHOD Commit() CLASS TODBC
 
-return ( ::nRetCode := SQLCommit( ::hEnv, ::hDbc ) )
+return ::nRetCode := SQLCommit( ::hEnv, ::hDbc )
 
 /*-----------------------------------------------------------------------*/
 
 METHOD RollBack() CLASS TODBC
 
-return ( ::nRetCode := SQLRollBack( ::hEnv, ::hDbc ) )
+return ::nRetCode := SQLRollBack( ::hEnv, ::hDbc )
 
 /*-----------------------------------------------------------------------*/
 
@@ -297,7 +297,7 @@ return cBuffer
 
 METHOD SetStmtOptions( nType, uBuffer ) CLASS TODBC
 
-return ( ::nRetCode := SQLSetStmtOption( ::hStmt, nType, uBuffer ) )
+return ::nRetCode := SQLSetStmtOption( ::hStmt, nType, uBuffer )
 
 /*-----------------------------------------------------------------------*/
 
@@ -312,7 +312,7 @@ METHOD SetSQL( cSQL ) CLASS TODBC
 
    ::cSQL := cSQL
 
-RETURN ( NIL )
+RETURN NIL
 
 /*-----------------------------------------------------------------------*/
 
@@ -419,13 +419,13 @@ METHOD Open() CLASS TODBC
       ::nRecNo := 1
 
       // Sets the Dataset state to active
-      ::Active := .t.
+      ::Active := .T.
 
       EXIT
 
    ENDDO
 
-RETURN ( ( nRet == SQL_SUCCESS ) )
+RETURN nRet == SQL_SUCCESS
 
 /*-----------------------------------------------------------------------*/
 // Only executes the SQL Statement
@@ -455,7 +455,7 @@ METHOD ExecSQL() CLASS TODBC
 
    ENDDO
 
-RETURN ( nRet )
+RETURN nRet
 
 /*-----------------------------------------------------------------------*/
 // Closes the dataset
@@ -468,13 +468,13 @@ METHOD CLOSE() CLASS TODBC
 
    // Reset all recordset related variables
    IF ::lCacheRS
-     ::aRecordSet:= {}
+     ::aRecordSet := {}
    ENDIF
-   ::nRecCount:= 0
-   ::nRecNo   := 0
-   ::lBof     := .T.
+   ::nRecCount := 0
+   ::nRecNo    := 0
+   ::lBof      := .T.
 
-RETURN ( NIL )
+RETURN NIL
 
 /*-----------------------------------------------------------------------*/
 // Returns the Field object for a named field
@@ -494,7 +494,7 @@ METHOD FieldByName( cField ) CLASS TODBC
 
    ENDIF
 
-RETURN ( xRet )
+RETURN xRet
 
 /*-----------------------------------------------------------------------*/
 // General fetch wrapper - used by next methods
@@ -572,7 +572,7 @@ METHOD Fetch( nFetchType, nOffset ) CLASS TODBC
       // TODO: Report error here
    ENDIF
 
-RETURN ( nResult )
+RETURN nResult
 
 /*-----------------------------------------------------------------------*/
 // Moves to next record on DataSet
@@ -593,7 +593,7 @@ METHOD NEXT () CLASS TODBC
      //TODO: Error handling
    endif
 
-RETURN ( nResult )
+RETURN nResult
 
 /*-----------------------------------------------------------------------*/
 // Moves to prior record on DataSet
@@ -613,7 +613,7 @@ METHOD Prior() CLASS TODBC
      //TODO: Error handling
    endif
 
-RETURN ( nResult )
+RETURN nResult
 
 /*-----------------------------------------------------------------------*/
 // Moves to first record on DataSet
@@ -629,7 +629,7 @@ METHOD First() CLASS TODBC
      //TODO: Error handling
    endif
 
-RETURN ( nResult )
+RETURN nResult
 
 /*-----------------------------------------------------------------------*/
 // Moves to the last record on DataSet
@@ -645,7 +645,7 @@ METHOD last() CLASS TODBC
      //TODO: Error handling
    endif
 
-RETURN ( nResult )
+RETURN nResult
 
 /*-----------------------------------------------------------------------*/
 // Moves the DataSet nSteps from the current record
@@ -662,7 +662,7 @@ METHOD MoveBy( nSteps ) CLASS TODBC
      //TODO: Error handling
    endif
 
-RETURN ( nResult )
+RETURN nResult
 
 /*-----------------------------------------------------------------------*/
 // Moves the DataSet to absolute record number
@@ -671,21 +671,21 @@ METHOD GOTO( nRecNo ) CLASS TODBC
 
    LOCAL nResult
 
-   nResult := ::Fetch(  SQL_FETCH_ABSOLUTE, nRecNo )
+   nResult := ::Fetch( SQL_FETCH_ABSOLUTE, nRecNo )
    if nResult == SQL_SUCCESS
      ::nRecno := nRecNo
    else
      //TODO: Error handling
    endif
 
-RETURN ( nResult )
+RETURN nResult
 
 /*-----------------------------------------------------------------------*/
 // Skips dataset to the next record - wrapper to Next()
 
 METHOD SKIP() CLASS TODBC
 
-RETURN ( ::Next() )
+RETURN ::Next()
 
 /*-----------------------------------------------------------------------*/
 // Checks for End of File (End of DataSet, actually)
@@ -703,35 +703,35 @@ METHOD eof() CLASS TODBC
       lResult := .T.
    endif
    
-RETURN ( lResult )
+RETURN lResult
 
 /*-----------------------------------------------------------------------*/
 // Checks for Begining of File
 
 METHOD bof() CLASS TODBC
 
-RETURN ( ::lBof )
+RETURN ::lBof
 
 /*-----------------------------------------------------------------------*/
 // Returns the current row in dataset
 
 METHOD RecNo() CLASS TODBC
 
-RETURN ( ::nRecNo )
+RETURN ::nRecNo
 
 /*-----------------------------------------------------------------------*/
 // Returns number of rows ( if that function is supported by ODBC driver )
 
 METHOD Lastrec() CLASS TODBC
 
-RETURN ( ::nRecCount )
+RETURN ::nRecCount
 
 /*-----------------------------------------------------------------------*/
 // Returns number of rows ( if that function is supported by ODBC driver )
 
 METHOD RecCount() CLASS TODBC
 
-RETURN ( ::nRecCount )
+RETURN ::nRecCount
 
 /*-----------------------------------------------------------------------*/
 // Loads current record data into the Fields collection
@@ -791,6 +791,6 @@ METHOD LoadData(nPos) CLASS TODBC
    next
    
 
-RETURN ( NIL )
+RETURN NIL
 
 *+ EOF: TODBC.PRG
diff --git a/harbour/contrib/hbw32/dllcall.c b/harbour/contrib/hbw32/dllcall.c
index adbcc34d5e..bf7ea3a9a6 100644
--- a/harbour/contrib/hbw32/dllcall.c
+++ b/harbour/contrib/hbw32/dllcall.c
@@ -738,7 +738,7 @@ HB_FUNC( DLLPREPARECALL )
       xec->hDLL = LoadLibraryA( xec->cDLL );
    }
    else if( ISNUM( 1 ) )
-      xec->hDLL = ( HMODULE ) hb_parnl( 1 );
+      xec->hDLL = ( HMODULE ) hb_parnint( 1 );
 
    if( xec->hDLL )
    {
@@ -779,12 +779,12 @@ HB_FUNC( DLLPREPARECALL )
 
 HB_FUNC( DLLLOAD )
 {
-   hb_retnl( ( long ) LoadLibraryA( ( LPCSTR ) hb_parcx( 1 ) ) ) ;
+   hb_retnint( ( HB_PTRDIFF ) LoadLibraryA( ( LPCSTR ) hb_parcx( 1 ) ) ) ;
 }
 
 HB_FUNC( DLLUNLOAD )
 {
-   hb_retl( FreeLibrary( ( HMODULE ) hb_parnl( 1 ) ) ) ;
+   hb_retl( FreeLibrary( ( HMODULE ) hb_parnint( 1 ) ) ) ;
 }
 
 HB_FUNC( DLLEXECUTECALL )
@@ -818,7 +818,7 @@ static LPVOID hb_getprocaddress( HMODULE hDLL, int i )
 
 HB_FUNC( DLLCALL )
 {
-   HMODULE hDLL = ISCHAR( 1 ) ? LoadLibraryA( hb_parc( 1 ) ) : ( HMODULE ) hb_parnl( 1 );
+   HMODULE hDLL = ISCHAR( 1 ) ? LoadLibraryA( hb_parc( 1 ) ) : ( HMODULE ) hb_parnint( 1 );
 
    if( hDLL && ( DWORD ) hDLL >= 32 )
    {
@@ -854,7 +854,7 @@ HB_FUNC( SETLASTERROR )
 
 HB_FUNC( GETPROCADDRESS )
 {
-   hb_retptr( ( void * ) hb_getprocaddress( ( HMODULE ) hb_parnl( 1 ), 2 ) );
+   hb_retptr( ( void * ) hb_getprocaddress( ( HMODULE ) hb_parnint( 1 ), 2 ) );
 }
 
 /* Call a DLL function from (x)Harbour, the first parameter is a pointer returned from
diff --git a/harbour/contrib/rddado/adordd.prg b/harbour/contrib/rddado/adordd.prg
index 172ca6a238..ec5c4fc038 100644
--- a/harbour/contrib/rddado/adordd.prg
+++ b/harbour/contrib/rddado/adordd.prg
@@ -135,7 +135,7 @@ static function ADO_CREATE( nWA, aOpenInfo )
    local oError
 
    do case
-      case Upper( Right( cDataBase, 4 ) ) == ".MDB"
+      case Lower( Right( cDataBase, 4 ) ) == ".mdb"
            if ! File( cDataBase )
               oCatalog:Create( "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + cDataBase )
            endif
@@ -455,7 +455,7 @@ static function ADO_PUTVALUE( nWA, nField, xValue )
    local aWAData := USRRDD_AREADATA( nWA )
    local oRecordSet := aWAData[ WA_RECORDSET ]
 
-   if ! aWAData[ WA_EOF ] .and. oRecordSet:Fields( nField - 1 ):Value != xValue
+   if ! aWAData[ WA_EOF ] .and. !( oRecordSet:Fields( nField - 1 ):Value == xValue )
       oRecordSet:Fields( nField - 1 ):Value := xValue
       TRY
          oRecordSet:Update()
@@ -612,7 +612,7 @@ static function ADO_CLEARREL( nWA )
 
    if nKeys > 0
       cKeyName := aWAData[ WA_CATALOG ]:Tables( aWAData[ WA_TABLENAME ] ):Keys( nKeys - 1 ):Name
-      if Upper( cKeyName ) != "PRIMARYKEY"
+      if !( Upper( cKeyName ) == "PRIMARYKEY" )
          aWAData[ WA_CATALOG ]:Tables( aWAData[ WA_TABLENAME ] ):Keys:Delete( cKeyName )
       endif
    endif