From ee657afaae9b16ddec4603165b66c3f258991c10 Mon Sep 17 00:00:00 2001 From: Viktor Szakats Date: Fri, 20 Jul 2012 04:48:37 +0000 Subject: [PATCH] 2012-07-20 06:44 UTC+0200 Viktor Szakats (harbour syenar.net) * examples/hbapollo/append.c * examples/hbapollo/dbdelim.c * examples/hbapollo/global.c * examples/hbapollo/sde.c * examples/hbapollo/sxapi.h * examples/hbapollo/tools.c * examples/hbapollo/use.c ! added 's_' prefix to static varnames ! one static var got a TOFIX, but probably more should have * cleaned externs * minor fixes (also to prev) * contrib/hbmisc/hb_f.c * contrib/rddsql/sqlbase.c * contrib/rddsql/sqlmix.c * contrib/sddfb/sddfb.c * contrib/sddmy/sddmy.c * contrib/sddodbc/sddodbc.c * contrib/sddpg/sddpg.c * uncrustified --- harbour/ChangeLog | 22 + harbour/contrib/hbmisc/hb_f.c | 241 +++--- harbour/contrib/rddsql/sqlbase.c | 689 ++++++++------- harbour/contrib/rddsql/sqlmix.c | 1217 ++++++++++++++------------- harbour/contrib/sddfb/sddfb.c | 308 +++---- harbour/contrib/sddmy/sddmy.c | 278 +++--- harbour/contrib/sddodbc/sddodbc.c | 268 +++--- harbour/contrib/sddpg/sddpg.c | 260 +++--- harbour/examples/hbapollo/append.c | 12 +- harbour/examples/hbapollo/dbdelim.c | 10 +- harbour/examples/hbapollo/global.c | 83 +- harbour/examples/hbapollo/sde.c | 10 - harbour/examples/hbapollo/sxapi.h | 14 +- harbour/examples/hbapollo/tools.c | 26 +- harbour/examples/hbapollo/use.c | 18 +- 15 files changed, 1733 insertions(+), 1723 deletions(-) diff --git a/harbour/ChangeLog b/harbour/ChangeLog index 8b03805124..a6f264b8c6 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -16,6 +16,28 @@ The license applies to all entries newer than 2009-04-28. */ +2012-07-20 06:44 UTC+0200 Viktor Szakats (harbour syenar.net) + * examples/hbapollo/append.c + * examples/hbapollo/dbdelim.c + * examples/hbapollo/global.c + * examples/hbapollo/sde.c + * examples/hbapollo/sxapi.h + * examples/hbapollo/tools.c + * examples/hbapollo/use.c + ! added 's_' prefix to static varnames + ! one static var got a TOFIX, but probably more should have + * cleaned externs + * minor fixes (also to prev) + + * contrib/hbmisc/hb_f.c + * contrib/rddsql/sqlbase.c + * contrib/rddsql/sqlmix.c + * contrib/sddfb/sddfb.c + * contrib/sddmy/sddmy.c + * contrib/sddodbc/sddodbc.c + * contrib/sddpg/sddpg.c + * uncrustified + 2012-07-19 19:39 UTC-0800 Pritpal Bedi (bedipritpal@hotmail.com) * contrib/hbide/hbqreportsmanager.prg * contrib/hbide/ideactions.prg diff --git a/harbour/contrib/hbmisc/hb_f.c b/harbour/contrib/hbmisc/hb_f.c index cc93c5586a..e23de63ce2 100644 --- a/harbour/contrib/hbmisc/hb_f.c +++ b/harbour/contrib/hbmisc/hb_f.c @@ -54,8 +54,8 @@ #include "hbapifs.h" -#define _B_SIZE 4096 -#define _C_SIZE 4096 +#define _B_SIZE 4096 +#define _C_SIZE 4096 static long last_rec[ 10 ]; static long recno[ 10 ]; @@ -70,9 +70,9 @@ static HB_BOOL isEof[ 10 ]; HB_FUNC( HB_FUSE ) { - PHB_ITEM arg1_it = hb_param( 1, HB_IT_STRING ); - PHB_ITEM arg2_it = hb_param( 2, HB_IT_NUMERIC ); - int open_flags; + PHB_ITEM arg1_it = hb_param( 1, HB_IT_STRING ); + PHB_ITEM arg2_it = hb_param( 2, HB_IT_NUMERIC ); + int open_flags; if( arg1_it ) { @@ -81,28 +81,28 @@ HB_FUNC( HB_FUSE ) else open_flags = 0; - handles[area] = hb_fsOpen( hb_parc( 1 ), ( HB_USHORT ) open_flags ); - offset[area] = 0; - recno[area] = 1; - b = ( char * ) hb_xgrab( _B_SIZE ); - c = ( char * ) hb_xgrab( _C_SIZE ); - lastbyte[area] = hb_fsSeekLarge( handles[ area ], 0, FS_END ); - isEof[area] = ( lastbyte[ area ] == 0 ); + handles[ area ] = hb_fsOpen( hb_parc( 1 ), ( HB_USHORT ) open_flags ); + offset[ area ] = 0; + recno[ area ] = 1; + b = ( char * ) hb_xgrab( _B_SIZE ); + c = ( char * ) hb_xgrab( _C_SIZE ); + lastbyte[ area ] = hb_fsSeekLarge( handles[ area ], 0, FS_END ); + isEof[ area ] = ( lastbyte[ area ] == 0 ); hb_retnint( handles[ area ] ); } else { - hb_fsClose( handles[area] ); + hb_fsClose( handles[ area ] ); hb_xfree( b ); hb_xfree( c ); hb_retnint( 1 ); - recno[area] = 0; - offset[area] = 0; - handles[area] = 0; - last_rec[area] = 0; - last_off[area] = 0; - lastbyte[area] = 0; - isEof[area] = HB_FALSE; + recno[ area ] = 0; + offset[ area ] = 0; + handles[ area ] = 0; + last_rec[ area ] = 0; + last_off[ area ] = 0; + lastbyte[ area ] = 0; + isEof[ area ] = HB_FALSE; } } @@ -115,86 +115,86 @@ HB_FUNC( HB_FRECNO ) static long hb_hbfskip( int recs ) { - HB_FOFFSET read_pos; - HB_ISIZ read_len; - HB_ISIZ x; - int y; + HB_FOFFSET read_pos; + HB_ISIZ read_len; + HB_ISIZ x; + int y; - HB_TRACE(HB_TR_DEBUG, ("hb_hbskip(%d)", recs)); + HB_TRACE( HB_TR_DEBUG, ( "hb_hbskip(%d)", recs ) ); if( recs > 0 ) { for( y = 0; y < recs; ++y ) { - hb_fsSeekLarge( handles[area], offset[area], FS_SET ); + hb_fsSeekLarge( handles[ area ], offset[ area ], FS_SET ); - read_len = hb_fsReadLarge( handles[area], b, _B_SIZE ); + read_len = hb_fsReadLarge( handles[ area ], b, _B_SIZE ); for( x = 0; x < read_len; ++x ) { - if( ((*(b + x) == 13) && (*(b + x + 1) == 10)) || - ((*(b + x) == 10) && (*(b + x + 1) == 13)) ) + if( ( ( *( b + x ) == 13 ) && ( *( b + x + 1 ) == 10 ) ) || + ( ( *( b + x ) == 10 ) && ( *( b + x + 1 ) == 13 ) ) ) { break; } } - if( (offset[area] + x + 2) < lastbyte[area] ) + if( ( offset[ area ] + x + 2 ) < lastbyte[ area ] ) { - isEof[area] = HB_FALSE; - offset[area] += (x + 2); - recno[area] += 1; + isEof[ area ] = HB_FALSE; + offset[ area ] += ( x + 2 ); + recno[ area ] += 1; } else - isEof[area] = HB_TRUE; + isEof[ area ] = HB_TRUE; } } else { - recs = -recs; - isEof[area] = HB_FALSE; + recs = -recs; + isEof[ area ] = HB_FALSE; - if( ( recno[area] - recs ) < 1 ) - return( 1 ); + if( ( recno[ area ] - recs ) < 1 ) + return 1; for( y = recs; y > 0; y-- ) { - if( offset[area] - _B_SIZE < 0 ) + if( offset[ area ] - _B_SIZE < 0 ) { read_pos = 0; - read_len = (size_t)offset[area]; + read_len = ( size_t ) offset[ area ]; } else { - read_pos = (size_t)(offset[area] - _B_SIZE); + read_pos = ( size_t ) ( offset[ area ] - _B_SIZE ); read_len = _B_SIZE; } - hb_fsSeekLarge( handles[area], read_pos, FS_SET ); - read_len = hb_fsReadLarge( handles[area], b, read_len ); + hb_fsSeekLarge( handles[ area ], read_pos, FS_SET ); + read_len = hb_fsReadLarge( handles[ area ], b, read_len ); for( x = read_len - 4; x >= 0; x-- ) { - if( ((*(b + x) == 13) && (*(b + x + 1) == 10)) || - ((*(b + x) == 10) && (*(b + x + 1) == 13)) ) + if( ( ( *( b + x ) == 13 ) && ( *( b + x + 1 ) == 10 ) ) || + ( ( *( b + x ) == 10 ) && ( *( b + x + 1 ) == 13 ) ) ) { break; } } if( x < 0 ) { - offset[area] = 0; - recno[area] = 1; + offset[ area ] = 0; + recno[ area ] = 1; } else { - offset[area] = read_pos + x + 2; - recno[area]--; + offset[ area ] = read_pos + x + 2; + recno[ area ]--; } } } - return recno[area]; + return recno[ area ]; } HB_FUNC( HB_FSKIP ) @@ -204,18 +204,18 @@ HB_FUNC( HB_FSKIP ) HB_FUNC( HB_FREADLN ) { - HB_ISIZ x; - HB_ISIZ read; + HB_ISIZ x; + HB_ISIZ read; - hb_fsSeekLarge( handles[area], offset[area], FS_SET ); + hb_fsSeekLarge( handles[ area ], offset[ area ], FS_SET ); - read = hb_fsReadLarge( handles[area], b, _B_SIZE ); + read = hb_fsReadLarge( handles[ area ], b, _B_SIZE ); for( x = 0; x < _B_SIZE; ++x ) { - if( ((*(b + x) == 13) && (*(b + x + 1) == 10)) || - ((*(b + x) == 10) && (*(b + x + 1) == 13)) || - (*(b + x) == 26) || ( x >= read) ) + if( ( ( *( b + x ) == 13 ) && ( *( b + x + 1 ) == 10 ) ) || + ( ( *( b + x ) == 10 ) && ( *( b + x + 1 ) == 13 ) ) || + ( *( b + x ) == 26 ) || ( x >= read ) ) { break; } @@ -226,33 +226,33 @@ HB_FUNC( HB_FREADLN ) HB_FUNC( HB_FEOF ) { - hb_retl( isEof[area] ); + hb_retl( isEof[ area ] ); } HB_FUNC( HB_FGOTO ) { - long target; - long last; + long target; + long last; target = hb_parnl( 1 ); - if( recno[area] > target ) + if( recno[ area ] > target ) { - while( recno[area] != target ) + while( recno[ area ] != target ) { - last = recno[area]; + last = recno[ area ]; hb_hbfskip( -1 ); - if( recno[area] == last ) + if( recno[ area ] == last ) break; } } else { - while( recno[area] != target ) + while( recno[ area ] != target ) { last = recno[ area ]; hb_hbfskip( 1 ); - if( recno[area] == last ) + if( recno[ area ] == last ) break; } } @@ -260,68 +260,69 @@ HB_FUNC( HB_FGOTO ) HB_FUNC( HB_FGOBOTTOM ) { - if( last_rec[area] != 0 ) + if( last_rec[ area ] != 0 ) { - recno[area] = last_rec[area]; - offset[area] = last_off[area]; + recno[ area ] = last_rec[ area ]; + offset[ area ] = last_off[ area ]; } else { - HB_ISIZ loc = 0; - HB_ISIZ len; - HB_FOFFSET last = offset[area]; + HB_ISIZ loc = 0; + HB_ISIZ len; + HB_FOFFSET last = offset[ area ]; do { HB_ISIZ x; - hb_fsSeekLarge( handles[area], offset[area], FS_SET ); - len = hb_fsReadLarge( handles[area], c, _C_SIZE ); + hb_fsSeekLarge( handles[ area ], offset[ area ], FS_SET ); + len = hb_fsReadLarge( handles[ area ], c, _C_SIZE ); for( x = 0; x < len; ++x ) { - if( ((*(c + x) == 13) && (*(c + x + 1) == 10)) || - ((*(c + x) == 10) && (*(c + x + 1) == 13)) || + if( ( ( *( c + x ) == 13 ) && ( *( c + x + 1 ) == 10 ) ) || + ( ( *( c + x ) == 10 ) && ( *( c + x + 1 ) == 13 ) ) || ( x - loc > _B_SIZE ) ) { - last = offset[area] + loc; - recno[area]++; + last = offset[ area ] + loc; + recno[ area ]++; ++x; - loc = x + 1; + loc = x + 1; } } - offset[area] += loc; + offset[ area ] += loc; - } while ( len == _C_SIZE ); + } + while( len == _C_SIZE ); - last_rec[area] = --recno[area]; - last_off[area] = last; + last_rec[ area ] = --recno[ area ]; + last_off[ area ] = last; } } HB_FUNC( HB_FGOTOP ) { - offset[area] = 0; - recno[area] = 1; - isEof[area] = (lastbyte[area] == 0); + offset[ area ] = 0; + recno[ area ] = 1; + isEof[ area ] = ( lastbyte[ area ] == 0 ); } HB_FUNC( HB_FLASTREC ) { - long old_rec; - HB_FOFFSET old_offset; - HB_BOOL bIsEof; + long old_rec; + HB_FOFFSET old_offset; + HB_BOOL bIsEof; - old_rec = recno[area]; - old_offset = offset[area]; - bIsEof = isEof[area]; + old_rec = recno[ area ]; + old_offset = offset[ area ]; + bIsEof = isEof[ area ]; HB_FUNC_EXEC( HB_FGOBOTTOM ); - hb_retnl( last_rec[area] ); + hb_retnl( last_rec[ area ] ); - recno[area] = old_rec; - offset[area] = old_offset; - isEof[area] = bIsEof; + recno[ area ] = old_rec; + offset[ area ] = old_offset; + isEof[ area ] = bIsEof; } HB_FUNC( HB_FSELECT ) @@ -335,12 +336,12 @@ HB_FUNC( HB_FSELECT ) HB_FUNC( HB_FINFO ) /* used for debugging */ { hb_reta( 6 ); - hb_storvni( area+1, -1, 1 ); - hb_storvni( last_rec[area], -1, 2 ); - hb_storvni( recno[area], -1, 3 ); - hb_storvnint( offset[area], -1, 4 ); - hb_storvnint( lastbyte[area], -1, 5 ); - hb_storvl( isEof[area], -1, 6 ); + hb_storvni( area + 1, -1, 1 ); + hb_storvni( last_rec[ area ], -1, 2 ); + hb_storvni( recno[ area ], -1, 3 ); + hb_storvnint( offset[ area ], -1, 4 ); + hb_storvnint( lastbyte[ area ], -1, 5 ); + hb_storvl( isEof[ area ], -1, 6 ); } HB_FUNC( HB_FREADANDSKIP ) @@ -359,19 +360,19 @@ HB_FUNC( HB_FREADANDSKIP ) It does its own skip and read, so an entire file can be read sequentially with just this function. -BH - --------------------------------------------------*/ - HB_ISIZ x = 0; - HB_ISIZ read; - HB_BOOL bInField = HB_FALSE, bHasCRLF = HB_FALSE; + --------------------------------------------------*/ + HB_ISIZ x = 0; + HB_ISIZ read; + HB_BOOL bInField = HB_FALSE, bHasCRLF = HB_FALSE; - hb_fsSeekLarge( handles[area], offset[area], FS_SET ); - read = hb_fsReadLarge( handles[area], b, _B_SIZE ); + hb_fsSeekLarge( handles[ area ], offset[ area ], FS_SET ); + read = hb_fsReadLarge( handles[ area ], b, _B_SIZE ); while( x < read ) { - if( *(b + x) == '"' ) + if( *( b + x ) == '"' ) { - bInField = !bInField ; + bInField = ! bInField; ++x; continue; } @@ -382,28 +383,28 @@ HB_FUNC( HB_FREADANDSKIP ) continue; } - if( ((*(b + x) == 13) && x < read-1 && (*(b + x + 1) == 10)) || - ((*(b + x) == 10) && x < read-1 && (*(b + x + 1) == 13)) ) + if( ( ( *( b + x ) == 13 ) && x < read - 1 && ( *( b + x + 1 ) == 10 ) ) || + ( ( *( b + x ) == 10 ) && x < read - 1 && ( *( b + x + 1 ) == 13 ) ) ) { - x += 2; + x += 2; bHasCRLF = HB_TRUE; break; } ++x; } - offset[area] = offset[area] + x; - recno[area] += 1; + offset[ area ] = offset[ area ] + x; + recno[ area ] += 1; /* See if there's more to read */ - if( !isEof[area ] ) + if( ! isEof[ area ] ) { #if defined( __DCC__ ) /* NOTE: Workaround for vxworks/diab/x86 5.8.0.0 compiler bug. */ - HB_BOOL f = (lastbyte[area] <= offset[area] + 1); - isEof[area] = f; + HB_BOOL f = ( lastbyte[ area ] <= offset[ area ] + 1 ); + isEof[ area ] = f; #else - isEof[area] = (lastbyte[area] <= offset[area] + 1); + isEof[ area ] = ( lastbyte[ area ] <= offset[ area ] + 1 ); #endif } - hb_retclen( b, x - (bHasCRLF ? 2 : 0) ); + hb_retclen( b, x - ( bHasCRLF ? 2 : 0 ) ); } diff --git a/harbour/contrib/rddsql/sqlbase.c b/harbour/contrib/rddsql/sqlbase.c index bfa1a891d8..4f991f8fe8 100644 --- a/harbour/contrib/rddsql/sqlbase.c +++ b/harbour/contrib/rddsql/sqlbase.c @@ -46,7 +46,7 @@ * If you write modifications of your own for Harbour, it is your choice * whether to permit this exception to apply to your modifications. * If you do not wish that, delete this exception notice. - * + * */ #include "hbapi.h" @@ -58,21 +58,21 @@ #include "hbtrace.h" -#define SUPERTABLE ( &sqlbaseSuper ) +#define SUPERTABLE ( &sqlbaseSuper ) -#define CONNECTION_LIST_EXPAND 4 +#define CONNECTION_LIST_EXPAND 4 -static HB_USHORT s_rddidSQLBASE = 0; -static SQLDDCONNECTION ** s_pConnection = NULL; -static HB_ULONG s_ulConnectionCount = 0; -static HB_ULONG s_ulConnectionCurrent = 0; -static char * s_szError = NULL; -static HB_ERRCODE s_errCode = 0; -static char * s_szQuery = NULL; -static PHB_ITEM s_pItemNewID = NULL; -static unsigned long s_ulAffectedRows = 0; +static HB_USHORT s_rddidSQLBASE = 0; +static SQLDDCONNECTION ** s_pConnection = NULL; +static HB_ULONG s_ulConnectionCount = 0; +static HB_ULONG s_ulConnectionCurrent = 0; +static char * s_szError = NULL; +static HB_ERRCODE s_errCode = 0; +static char * s_szQuery = NULL; +static PHB_ITEM s_pItemNewID = NULL; +static unsigned long s_ulAffectedRows = 0; -static RDDFUNCS sqlbaseSuper; +static RDDFUNCS sqlbaseSuper; void hb_rddsqlSetError( HB_ERRCODE errCode, const char * szError, const char * szQuery, PHB_ITEM pItem, unsigned long ulAffectedRows ) @@ -106,14 +106,14 @@ void hb_rddsqlSetError( HB_ERRCODE errCode, const char * szError, const char * s static HB_ERRCODE hb_errRT_SQLBASE( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation ) { - PHB_ITEM pError; - HB_ERRCODE iRet = HB_FAILURE; + PHB_ITEM pError; + HB_ERRCODE iRet = HB_FAILURE; - if ( hb_vmRequestQuery() == 0 ) + if( hb_vmRequestQuery() == 0 ) { - pError = hb_errRT_New( ES_ERROR, "SQLBASE", errGenCode, errSubCode, szDescription, szOperation, 0, EF_NONE ); - iRet = hb_errLaunch( pError ); - hb_itemRelease( pError ); + pError = hb_errRT_New( ES_ERROR, "SQLBASE", errGenCode, errSubCode, szDescription, szOperation, 0, EF_NONE ); + iRet = hb_errLaunch( pError ); + hb_itemRelease( pError ); } return iRet; } @@ -134,14 +134,14 @@ static HB_ERRCODE sddGetVarLen( SQLBASEAREAP pArea, HB_USHORT uiIndex, HB_ULONG static SDDNODE sddNull = { NULL, "NULL", - ( SDDFUNC_CONNECT ) sddConnect, + ( SDDFUNC_CONNECT ) sddConnect, ( SDDFUNC_DISCONNECT ) sddDisconnect, - ( SDDFUNC_EXECUTE ) sddExecute, - ( SDDFUNC_OPEN ) sddOpen, - ( SDDFUNC_CLOSE ) sddClose, - ( SDDFUNC_GOTO ) sddGoTo, - ( SDDFUNC_GETVALUE ) sddGetValue, - ( SDDFUNC_GETVARLEN ) sddGetVarLen + ( SDDFUNC_EXECUTE ) sddExecute, + ( SDDFUNC_OPEN ) sddOpen, + ( SDDFUNC_CLOSE ) sddClose, + ( SDDFUNC_GOTO ) sddGoTo, + ( SDDFUNC_GETVALUE ) sddGetValue, + ( SDDFUNC_GETVARLEN ) sddGetVarLen }; @@ -188,19 +188,19 @@ static HB_ERRCODE sddClose( SQLBASEAREAP pArea ) static HB_ERRCODE sddGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) { - if ( ulRecNo == 0 || ulRecNo > pArea->ulRecCount ) + if( ulRecNo == 0 || ulRecNo > pArea->ulRecCount ) { - pArea->pRecord = pArea->pRow[ 0 ]; - pArea->bRecordFlags = pArea->pRowFlags[ 0 ]; + pArea->pRecord = pArea->pRow[ 0 ]; + pArea->bRecordFlags = pArea->pRowFlags[ 0 ]; - pArea->fPositioned = HB_FALSE; + pArea->fPositioned = HB_FALSE; } else { - pArea->pRecord = pArea->pRow[ ulRecNo ]; - pArea->bRecordFlags = pArea->pRowFlags[ ulRecNo ]; + pArea->pRecord = pArea->pRow[ ulRecNo ]; + pArea->bRecordFlags = pArea->pRowFlags[ ulRecNo ]; - pArea->fPositioned = HB_TRUE; + pArea->fPositioned = HB_TRUE; } return HB_SUCCESS; } @@ -253,14 +253,14 @@ int hb_sddRegister( PSDDNODE pSdd ) if( pSdd->GetVarLen == NULL ) pSdd->GetVarLen = sddNull.GetVarLen; - while ( pNode ) + while( pNode ) { - if ( ! hb_stricmp( pNode->Name, pSdd->Name ) ) + if( ! hb_stricmp( pNode->Name, pSdd->Name ) ) return 0; pNode = pNode->pNext; } pSdd->pNext = s_pSdd; - s_pSdd = pSdd; + s_pSdd = pSdd; return 1; } @@ -269,17 +269,17 @@ int hb_sddRegister( PSDDNODE pSdd ) static HB_ERRCODE sqlbaseGoBottom( SQLBASEAREAP pArea ) { - if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) + if( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( ! pArea->fFetched && pArea->pSDD->GoTo( pArea, ( HB_ULONG ) -1 ) == HB_FAILURE ) + if( ! pArea->fFetched && pArea->pSDD->GoTo( pArea, ( HB_ULONG ) -1 ) == HB_FAILURE ) return HB_FAILURE; - pArea->area.fTop = HB_FALSE; - pArea->area.fBottom = HB_TRUE; + pArea->area.fTop = HB_FALSE; + pArea->area.fBottom = HB_TRUE; - if ( SELF_GOTO( ( AREAP ) pArea, pArea->ulRecCount ) != HB_SUCCESS ) + if( SELF_GOTO( ( AREAP ) pArea, pArea->ulRecCount ) != HB_SUCCESS ) return HB_FAILURE; return SELF_SKIPFILTER( ( AREAP ) pArea, -1 ); @@ -288,21 +288,21 @@ static HB_ERRCODE sqlbaseGoBottom( SQLBASEAREAP pArea ) static HB_ERRCODE sqlbaseGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) { - if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) + if( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( pArea->pSDD->GoTo( pArea, ulRecNo ) == HB_FAILURE ) + if( pArea->pSDD->GoTo( pArea, ulRecNo ) == HB_FAILURE ) return HB_FAILURE; - if ( pArea->fPositioned ) + if( pArea->fPositioned ) { - pArea->ulRecNo = ulRecNo; - pArea->area.fBof = pArea->area.fEof = HB_FALSE; + pArea->ulRecNo = ulRecNo; + pArea->area.fBof = pArea->area.fEof = HB_FALSE; } else { - pArea->ulRecNo = pArea->ulRecCount + 1; - pArea->area.fBof = pArea->area.fEof = HB_TRUE; + pArea->ulRecNo = pArea->ulRecCount + 1; + pArea->area.fBof = pArea->area.fEof = HB_TRUE; } pArea->area.fFound = HB_FALSE; @@ -314,7 +314,7 @@ static HB_ERRCODE sqlbaseGoToId( SQLBASEAREAP pArea, PHB_ITEM pItem ) { PHB_ITEM pError; - if ( HB_IS_NUMERIC( pItem ) ) + if( HB_IS_NUMERIC( pItem ) ) return SELF_GOTO( ( AREAP ) pArea, hb_itemGetNL( pItem ) ); else { @@ -331,10 +331,10 @@ static HB_ERRCODE sqlbaseGoToId( SQLBASEAREAP pArea, PHB_ITEM pItem ) static HB_ERRCODE sqlbaseGoTop( SQLBASEAREAP pArea ) { - pArea->area.fTop = HB_TRUE; - pArea->area.fBottom = HB_FALSE; + pArea->area.fTop = HB_TRUE; + pArea->area.fBottom = HB_FALSE; - if ( SELF_GOTO( ( AREAP ) pArea, 1 ) == HB_FAILURE ) + if( SELF_GOTO( ( AREAP ) pArea, 1 ) == HB_FAILURE ) return HB_FAILURE; return SELF_SKIPFILTER( ( AREAP ) pArea, 1 ); @@ -345,28 +345,28 @@ static HB_ERRCODE sqlbaseSkip( SQLBASEAREAP pArea, HB_LONG lToSkip ) { HB_ERRCODE errCode; - if ( pArea->lpdbPendingRel ) + if( pArea->lpdbPendingRel ) { - if ( SELF_FORCEREL( ( AREAP ) pArea ) != HB_SUCCESS ) + if( SELF_FORCEREL( ( AREAP ) pArea ) != HB_SUCCESS ) return HB_FAILURE; } pArea->area.fTop = pArea->area.fBottom = HB_FALSE; - if ( lToSkip == 0 || hb_setGetDeleted() || + if( lToSkip == 0 || hb_setGetDeleted() || pArea->area.dbfi.itmCobExpr || pArea->area.dbfi.fFilter ) return SUPER_SKIP( ( AREAP ) pArea, lToSkip ); errCode = SELF_SKIPRAW( ( AREAP ) pArea, lToSkip ); /* Move first record and set Bof flag */ - if ( errCode == HB_SUCCESS && pArea->area.fBof && lToSkip < 0 ) + if( errCode == HB_SUCCESS && pArea->area.fBof && lToSkip < 0 ) { - errCode = SELF_GOTOP( ( AREAP ) pArea ); - pArea->area.fBof = HB_TRUE; + errCode = SELF_GOTOP( ( AREAP ) pArea ); + pArea->area.fBof = HB_TRUE; } - if ( lToSkip < 0 ) + if( lToSkip < 0 ) pArea->area.fEof = HB_FALSE; else /* if ( lToSkip > 0 ) */ pArea->area.fBof = HB_FALSE; @@ -379,31 +379,31 @@ static HB_ERRCODE sqlbaseSkipRaw( SQLBASEAREAP pArea, HB_LONG lToSkip ) { HB_ERRCODE errCode; - if ( pArea->lpdbPendingRel ) + if( pArea->lpdbPendingRel ) { - if ( SELF_FORCEREL( ( AREAP ) pArea ) != HB_SUCCESS ) + if( SELF_FORCEREL( ( AREAP ) pArea ) != HB_SUCCESS ) return HB_FAILURE; } - if ( lToSkip == 0 ) + if( lToSkip == 0 ) { /* TODO: maybe gocold is enough here?! */ HB_BOOL bBof, bEof; /* Save flags */ - bBof = pArea->area.fBof; - bEof = pArea->area.fEof; + bBof = pArea->area.fBof; + bEof = pArea->area.fEof; - errCode = SELF_GOTO( ( AREAP ) pArea, pArea->ulRecNo ); + errCode = SELF_GOTO( ( AREAP ) pArea, pArea->ulRecNo ); /* Restore flags */ - pArea->area.fBof = bBof; - pArea->area.fEof = bEof; + pArea->area.fBof = bBof; + pArea->area.fEof = bEof; } - else if ( lToSkip < 0 && ( HB_ULONG ) ( -lToSkip ) >= pArea->ulRecNo ) + else if( lToSkip < 0 && ( HB_ULONG ) ( -lToSkip ) >= pArea->ulRecNo ) { - errCode = SELF_GOTO( ( AREAP ) pArea, 1 ); - pArea->area.fBof = HB_TRUE; + errCode = SELF_GOTO( ( AREAP ) pArea, 1 ); + pArea->area.fBof = HB_TRUE; } else { @@ -419,33 +419,33 @@ static HB_ERRCODE sqlbaseAppend( SQLBASEAREAP pArea, HB_BOOL bUnLockAll ) HB_SYMBOL_UNUSED( bUnLockAll ); /* This GOTO is GOCOLD + GOEOF */ - if ( SELF_GOTO( ( AREAP ) pArea, 0 ) == HB_FAILURE ) + if( SELF_GOTO( ( AREAP ) pArea, 0 ) == HB_FAILURE ) return HB_FAILURE; - if ( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == HB_FAILURE ) + if( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( pArea->ulRecCount + 1 >= pArea->ulRecMax ) + if( pArea->ulRecCount + 1 >= pArea->ulRecMax ) { - pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) ); - pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) ); - pArea->ulRecMax += SQLDD_ROWSET_RESIZE; + pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) ); + pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) ); + pArea->ulRecMax += SQLDD_ROWSET_RESIZE; } - pArea->fAppend = pArea->fPositioned = HB_TRUE; + pArea->fAppend = pArea->fPositioned = HB_TRUE; pArea->ulRecCount++; - pArea->ulRecNo = pArea->ulRecCount; - pArea->area.fBof = pArea->area.fEof = pArea->area.fFound = HB_FALSE; + pArea->ulRecNo = pArea->ulRecCount; + pArea->area.fBof = pArea->area.fEof = pArea->area.fFound = HB_FALSE; return HB_SUCCESS; } static HB_ERRCODE sqlbaseDeleteRec( SQLBASEAREAP pArea ) { - if ( ! pArea->fPositioned ) + if( ! pArea->fPositioned ) return HB_SUCCESS; - if ( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == HB_FAILURE ) + if( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; pArea->bRecordFlags |= SQLDD_FLAG_DELETED; @@ -453,9 +453,9 @@ static HB_ERRCODE sqlbaseDeleteRec( SQLBASEAREAP pArea ) } -static HB_ERRCODE sqlbaseDeleted( SQLBASEAREAP pArea, HB_BOOL* pDeleted ) +static HB_ERRCODE sqlbaseDeleted( SQLBASEAREAP pArea, HB_BOOL * pDeleted ) { - * pDeleted = pArea->bRecordFlags & SQLDD_FLAG_DELETED; + *pDeleted = pArea->bRecordFlags & SQLDD_FLAG_DELETED; return HB_SUCCESS; } @@ -465,7 +465,7 @@ static HB_ERRCODE sqlbaseGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_IT if( uiIndex == 0 || uiIndex > pArea->area.uiFieldCount ) return HB_FAILURE; - if ( pArea->bRecordFlags & SQLDD_FLAG_CACHED ) + if( pArea->bRecordFlags & SQLDD_FLAG_CACHED ) { hb_arrayGet( ( PHB_ITEM ) pArea->pRecord, uiIndex, pItem ); return HB_SUCCESS; @@ -476,30 +476,30 @@ static HB_ERRCODE sqlbaseGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_IT static HB_ERRCODE sqlbaseGetVarLen( SQLBASEAREAP pArea, HB_USHORT uiIndex, HB_ULONG * pLength ) { - /* TODO: should we use this code? - if ( pArea->area.lpFields[ uiIndex ].uiType == HB_IT_MEMO ) - { - return pArea->pSDD->GetVarLen( pArea, uiIndex, pLength ); - } - */ + /* TODO: should we use this code? + if ( pArea->area.lpFields[ uiIndex ].uiType == HB_IT_MEMO ) + { + return pArea->pSDD->GetVarLen( pArea, uiIndex, pLength ); + } + */ - * pLength = pArea->area.lpFields[ uiIndex - 1 ].uiLen; - return HB_SUCCESS; + *pLength = pArea->area.lpFields[ uiIndex - 1 ].uiLen; + return HB_SUCCESS; } static HB_ERRCODE sqlbaseGoCold( SQLBASEAREAP pArea ) { - if ( pArea->fRecordChanged ) + if( pArea->fRecordChanged ) { - if ( ! pArea->fAppend && pArea->pRowFlags[ pArea->ulRecNo ] & SQLDD_FLAG_CACHED ) + if( ! pArea->fAppend && pArea->pRowFlags[ pArea->ulRecNo ] & SQLDD_FLAG_CACHED ) { - hb_itemRelease( (PHB_ITEM) ( pArea->pRow[ pArea->ulRecNo ] ) ); + hb_itemRelease( ( PHB_ITEM ) ( pArea->pRow[ pArea->ulRecNo ] ) ); } - pArea->pRow[ pArea->ulRecNo ] = pArea->pRecord; - pArea->pRowFlags[ pArea->ulRecNo ] = pArea->bRecordFlags; - pArea->fRecordChanged = HB_FALSE; - pArea->fAppend = HB_FALSE; + pArea->pRow[ pArea->ulRecNo ] = pArea->pRecord; + pArea->pRowFlags[ pArea->ulRecNo ] = pArea->bRecordFlags; + pArea->fRecordChanged = HB_FALSE; + pArea->fAppend = HB_FALSE; } return HB_SUCCESS; } @@ -507,59 +507,59 @@ static HB_ERRCODE sqlbaseGoCold( SQLBASEAREAP pArea ) static HB_ERRCODE sqlbaseGoHot( SQLBASEAREAP pArea ) { - PHB_ITEM pArray, pItem; - HB_USHORT us; + PHB_ITEM pArray, pItem; + HB_USHORT us; pArray = hb_itemArrayNew( pArea->area.uiFieldCount ); - for ( us = 1; us <= pArea->area.uiFieldCount; us++ ) + for( us = 1; us <= pArea->area.uiFieldCount; us++ ) { pItem = hb_itemNew( NULL ); - if ( SELF_GETVALUE( ( AREAP ) pArea, us, pItem ) == HB_SUCCESS ) + if( SELF_GETVALUE( ( AREAP ) pArea, us, pItem ) == HB_SUCCESS ) hb_arraySetForward( pArray, us, pItem ); hb_itemRelease( pItem ); } - pArea->pRecord = pArray; - pArea->bRecordFlags |= SQLDD_FLAG_CACHED; - pArea->fRecordChanged = HB_TRUE; + pArea->pRecord = pArray; + pArea->bRecordFlags |= SQLDD_FLAG_CACHED; + pArea->fRecordChanged = HB_TRUE; return HB_SUCCESS; } static HB_ERRCODE sqlbasePutValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem ) { - LPFIELD pField; - HB_ERRCODE errCode; + LPFIELD pField; + HB_ERRCODE errCode; if( uiIndex == 0 || uiIndex > pArea->area.uiFieldCount ) return HB_FAILURE; - if ( ! pArea->fPositioned ) + if( ! pArea->fPositioned ) return HB_SUCCESS; - if ( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == HB_FAILURE ) + if( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - errCode = HB_SUCCESS; - pField = pArea->area.lpFields + ( uiIndex - 1 ); + errCode = HB_SUCCESS; + pField = pArea->area.lpFields + ( uiIndex - 1 ); - if ( ( ( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) ) && ( pField->uiType == HB_FT_STRING || pField->uiType == HB_FT_MEMO ) ) || - ( HB_IS_DATE( pItem ) && pField->uiType == HB_FT_DATE ) || - ( HB_IS_TIMESTAMP( pItem ) && pField->uiType == HB_FT_TIMESTAMP ) || - ( HB_IS_NUMBER( pItem ) && ( pField->uiType == HB_FT_INTEGER || pField->uiType == HB_FT_LONG || - pField->uiType == HB_FT_FLOAT || pField->uiType == HB_FT_DOUBLE ) ) || - ( HB_IS_LOGICAL( pItem ) && pField->uiType == HB_FT_LOGICAL ) || - HB_IS_NIL( pItem ) ) + if( ( ( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) ) && ( pField->uiType == HB_FT_STRING || pField->uiType == HB_FT_MEMO ) ) || + ( HB_IS_DATE( pItem ) && pField->uiType == HB_FT_DATE ) || + ( HB_IS_TIMESTAMP( pItem ) && pField->uiType == HB_FT_TIMESTAMP ) || + ( HB_IS_NUMBER( pItem ) && ( pField->uiType == HB_FT_INTEGER || pField->uiType == HB_FT_LONG || + pField->uiType == HB_FT_FLOAT || pField->uiType == HB_FT_DOUBLE ) ) || + ( HB_IS_LOGICAL( pItem ) && pField->uiType == HB_FT_LOGICAL ) || + HB_IS_NIL( pItem ) ) { - hb_arraySet( ( PHB_ITEM ) pArea->pRecord, uiIndex, pItem ); + hb_arraySet( ( PHB_ITEM ) pArea->pRecord, uiIndex, pItem ); } else { - PHB_ITEM pError; + PHB_ITEM pError; pError = hb_errNew(); hb_errPutGenCode( pError, EG_DATATYPE ); hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_DATATYPE ) ); - hb_errPutOperation( pError, hb_dynsymName( (PHB_DYNS) pField->sym ) ); + hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) ); hb_errPutSubCode( pError, errCode ); hb_errPutFlags( pError, EF_CANDEFAULT ); errCode = SELF_ERROR( ( AREAP ) pArea, pError ); @@ -572,10 +572,10 @@ static HB_ERRCODE sqlbasePutValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_IT static HB_ERRCODE sqlbaseRecall( SQLBASEAREAP pArea ) { - if ( ! pArea->fPositioned ) + if( ! pArea->fPositioned ) return HB_SUCCESS; - if ( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) != HB_SUCCESS ) + if( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) != HB_SUCCESS ) return HB_FAILURE; pArea->bRecordFlags &= ~SQLDD_FLAG_DELETED; @@ -585,22 +585,22 @@ static HB_ERRCODE sqlbaseRecall( SQLBASEAREAP pArea ) static HB_ERRCODE sqlbaseRecCount( SQLBASEAREAP pArea, HB_ULONG * pRecCount ) { - * pRecCount = pArea->ulRecCount; + *pRecCount = pArea->ulRecCount; return HB_SUCCESS; } static HB_ERRCODE sqlbaseRecNo( SQLBASEAREAP pArea, HB_ULONG * ulRecNo ) { - * ulRecNo = pArea->ulRecNo; + *ulRecNo = pArea->ulRecNo; return HB_SUCCESS; } static HB_ERRCODE sqlbaseRecId( SQLBASEAREAP pArea, PHB_ITEM pRecNo ) { - HB_ERRCODE errCode; - HB_ULONG ulRecNo; + HB_ERRCODE errCode; + HB_ULONG ulRecNo; errCode = SELF_RECNO( ( AREAP ) pArea, &ulRecNo ); hb_itemPutNInt( pRecNo, ulRecNo ); @@ -610,33 +610,33 @@ static HB_ERRCODE sqlbaseRecId( SQLBASEAREAP pArea, PHB_ITEM pRecNo ) static HB_ERRCODE sqlbaseClose( SQLBASEAREAP pArea ) { - if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) + if( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( SUPER_CLOSE( ( AREAP ) pArea ) == HB_FAILURE ) + if( SUPER_CLOSE( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( pArea->pSDD ) + if( pArea->pSDD ) pArea->pSDD->Close( pArea ); - if ( pArea->pRow ) + if( pArea->pRow ) { HB_ULONG ulIndex; - for ( ulIndex = 0; ulIndex <= pArea->ulRecCount; ulIndex++ ) + for( ulIndex = 0; ulIndex <= pArea->ulRecCount; ulIndex++ ) { - if ( pArea->pRowFlags[ ulIndex ] & SQLDD_FLAG_CACHED ) + if( pArea->pRowFlags[ ulIndex ] & SQLDD_FLAG_CACHED ) { - hb_itemRelease( (PHB_ITEM) pArea->pRow[ ulIndex ] ); + hb_itemRelease( ( PHB_ITEM ) pArea->pRow[ ulIndex ] ); } } hb_xfree( pArea->pRow ); hb_xfree( pArea->pRowFlags ); - pArea->pRow = NULL; - pArea->pRowFlags = NULL; + pArea->pRow = NULL; + pArea->pRowFlags = NULL; } - if ( pArea->szQuery ) + if( pArea->szQuery ) { hb_xfree( pArea->szQuery ); pArea->szQuery = NULL; @@ -659,18 +659,18 @@ static HB_ERRCODE sqlbaseCreate( SQLBASEAREAP pArea, LPDBOPENINFO pOpenInfo ) pArea->ulConnection = pOpenInfo->ulConnection ? pOpenInfo->ulConnection : s_ulConnectionCurrent; - if ( pArea->ulConnection > s_ulConnectionCount || - ( pArea->ulConnection && ! s_pConnection[ pArea->ulConnection - 1 ] ) ) + if( pArea->ulConnection > s_ulConnectionCount || + ( pArea->ulConnection && ! s_pConnection[ pArea->ulConnection - 1 ] ) ) { hb_errRT_SQLBASE( EG_OPEN, ESQLDD_NOTCONNECTED, "Not connected", NULL ); return HB_FAILURE; } - if ( pArea->ulConnection ) + if( pArea->ulConnection ) { - pArea->pConnection = s_pConnection[ pArea->ulConnection - 1 ]; + pArea->pConnection = s_pConnection[ pArea->ulConnection - 1 ]; pArea->pConnection->uiAreaCount++; - pArea->pSDD = pArea->pConnection->pSDD; + pArea->pSDD = pArea->pConnection->pSDD; } else { @@ -679,22 +679,22 @@ static HB_ERRCODE sqlbaseCreate( SQLBASEAREAP pArea, LPDBOPENINFO pOpenInfo ) pItemEof = hb_itemArrayNew( pArea->area.uiFieldCount ); - bError = HB_FALSE; - for ( uiCount = 0; uiCount < pArea->area.uiFieldCount; uiCount++ ) + bError = HB_FALSE; + for( uiCount = 0; uiCount < pArea->area.uiFieldCount; uiCount++ ) { LPFIELD pField = pArea->area.lpFields + uiCount; - switch ( pField->uiType ) + switch( pField->uiType ) { case HB_FT_STRING: { - char* pStr; + char * pStr; - pStr = ( char * ) hb_xgrab( pField->uiLen + 1 ); + pStr = ( char * ) hb_xgrab( pField->uiLen + 1 ); memset( pStr, ' ', pField->uiLen ); - pStr[ pField->uiLen ] = '\0'; + pStr[ pField->uiLen ] = '\0'; - pItem = hb_itemPutCL( NULL, pStr, pField->uiLen ); + pItem = hb_itemPutCL( NULL, pStr, pField->uiLen ); hb_xfree( pStr ); break; } @@ -704,14 +704,14 @@ static HB_ERRCODE sqlbaseCreate( SQLBASEAREAP pArea, LPDBOPENINFO pOpenInfo ) break; case HB_FT_INTEGER: - if ( pField->uiDec ) + if( pField->uiDec ) pItem = hb_itemPutND( NULL, 0.0 ); else pItem = hb_itemPutNI( NULL, 0 ); break; case HB_FT_LONG: - if ( pField->uiDec ) + if( pField->uiDec ) pItem = hb_itemPutND( NULL, 0.0 ); else pItem = hb_itemPutNL( NULL, 0 ); @@ -734,19 +734,19 @@ static HB_ERRCODE sqlbaseCreate( SQLBASEAREAP pArea, LPDBOPENINFO pOpenInfo ) break; default: - pItem = hb_itemNew( NULL ); - bError = HB_TRUE; + pItem = hb_itemNew( NULL ); + bError = HB_TRUE; break; } hb_arraySetForward( pItemEof, uiCount + 1, pItem ); hb_itemRelease( pItem ); - if ( bError ) + if( bError ) break; } - if ( bError ) + if( bError ) { hb_itemClear( pItemEof ); hb_itemRelease( pItemEof ); @@ -755,17 +755,17 @@ static HB_ERRCODE sqlbaseCreate( SQLBASEAREAP pArea, LPDBOPENINFO pOpenInfo ) return HB_FAILURE; } - pArea->ulRecCount = 0; + pArea->ulRecCount = 0; - pArea->pRow = ( void ** ) hb_xalloc( SQLDD_ROWSET_RESIZE * sizeof( void * ) ); - pArea->pRowFlags = ( HB_BYTE * ) hb_xalloc( SQLDD_ROWSET_RESIZE * sizeof( HB_BYTE ) ); - pArea->ulRecMax = SQLDD_ROWSET_RESIZE; + pArea->pRow = ( void ** ) hb_xalloc( SQLDD_ROWSET_RESIZE * sizeof( void * ) ); + pArea->pRowFlags = ( HB_BYTE * ) hb_xalloc( SQLDD_ROWSET_RESIZE * sizeof( HB_BYTE ) ); + pArea->ulRecMax = SQLDD_ROWSET_RESIZE; - * (pArea->pRow) = pItemEof; - pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; - pArea->fFetched = HB_TRUE; + *( pArea->pRow ) = pItemEof; + pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; + pArea->fFetched = HB_TRUE; - if ( SUPER_CREATE( ( AREAP ) pArea, pOpenInfo ) != HB_SUCCESS ) + if( SUPER_CREATE( ( AREAP ) pArea, pOpenInfo ) != HB_SUCCESS ) { SELF_CLOSE( ( AREAP ) pArea ); return HB_FAILURE; @@ -793,31 +793,31 @@ static HB_ERRCODE sqlbaseInfo( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM p static HB_ERRCODE sqlbaseOpen( SQLBASEAREAP pArea, LPDBOPENINFO pOpenInfo ) { - HB_ERRCODE errCode; + HB_ERRCODE errCode; pArea->ulConnection = pOpenInfo->ulConnection ? pOpenInfo->ulConnection : s_ulConnectionCurrent; - if ( pArea->ulConnection == 0 || pArea->ulConnection > s_ulConnectionCount || - ! s_pConnection[ pArea->ulConnection - 1 ] ) + if( pArea->ulConnection == 0 || pArea->ulConnection > s_ulConnectionCount || + ! s_pConnection[ pArea->ulConnection - 1 ] ) { hb_errRT_SQLBASE( EG_OPEN, ESQLDD_NOTCONNECTED, "Not connected", NULL ); return HB_FAILURE; } - if ( pArea->area.uiFieldCount ) + if( pArea->area.uiFieldCount ) /* This should not happen (in __dbTrans()), because RDD is registered with RDT_FULL */ return HB_FAILURE; - pArea->pConnection = s_pConnection[ pArea->ulConnection - 1 ]; + pArea->pConnection = s_pConnection[ pArea->ulConnection - 1 ]; pArea->pConnection->uiAreaCount++; - pArea->pSDD = pArea->pConnection->pSDD; + pArea->pSDD = pArea->pConnection->pSDD; /* filename is a query */ - pArea->szQuery = hb_strdup( pOpenInfo->abName ); + pArea->szQuery = hb_strdup( pOpenInfo->abName ); - errCode = pArea->pSDD->Open( pArea ); + errCode = pArea->pSDD->Open( pArea ); - if ( errCode == HB_SUCCESS ) + if( errCode == HB_SUCCESS ) { errCode = SUPER_OPEN( ( AREAP ) pArea, pOpenInfo ); } @@ -835,14 +835,14 @@ static HB_ERRCODE sqlbaseStructSize( SQLBASEAREAP pArea, HB_USHORT * uiSize ) { HB_SYMBOL_UNUSED( pArea ); - * uiSize = sizeof( SQLBASEAREA ); + *uiSize = sizeof( SQLBASEAREA ); return HB_SUCCESS; } /* -static HB_ERRCODE sqlbaseChildEnd( SQLBASEAREAP pArea, LPDBRELINFO pRelInfo ) -{ + static HB_ERRCODE sqlbaseChildEnd( SQLBASEAREAP pArea, LPDBRELINFO pRelInfo ) + { HB_ERRCODE errCode; if ( pArea->lpdbPendingRel == pRelInfo ) @@ -851,19 +851,19 @@ static HB_ERRCODE sqlbaseChildEnd( SQLBASEAREAP pArea, LPDBRELINFO pRelInfo ) errCode = HB_SUCCESS; SUPER_CHILDEND( ( AREAP ) pArea, pRelInfo ); return errCode; -} + } -static HB_ERRCODE sqlbaseChildStart( SQLBASEAREAP pArea, LPDBRELINFO pRelInfo ) -{ + static HB_ERRCODE sqlbaseChildStart( SQLBASEAREAP pArea, LPDBRELINFO pRelInfo ) + { if ( SELF_CHILDSYNC( ( AREAP ) pArea, pRelInfo ) != HB_SUCCESS ) return HB_FAILURE; return SUPER_CHILDSTART( ( AREAP ) pArea, pRelInfo ); -} + } -static HB_ERRCODE sqlbaseChildSync( SQLBASEAREAP pArea, LPDBRELINFO pRelInfo ) -{ + static HB_ERRCODE sqlbaseChildSync( SQLBASEAREAP pArea, LPDBRELINFO pRelInfo ) + { if ( SELF_GOCOLD( ( AREAP ) pArea ) != HB_SUCCESS ) return HB_FAILURE; @@ -873,11 +873,11 @@ static HB_ERRCODE sqlbaseChildSync( SQLBASEAREAP pArea, LPDBRELINFO pRelInfo ) return SELF_SYNCCHILDREN( ( AREAP ) pArea ); return HB_SUCCESS; -} + } -static HB_ERRCODE sqlbaseForceRel( SQLBASEAREAP pArea ) -{ + static HB_ERRCODE sqlbaseForceRel( SQLBASEAREAP pArea ) + { if ( pArea->lpdbPendingRel ) { LPDBRELINFO lpdbPendingRel; @@ -887,19 +887,19 @@ static HB_ERRCODE sqlbaseForceRel( SQLBASEAREAP pArea ) return SELF_RELEVAL( ( AREAP ) pArea, lpdbPendingRel ); } return HB_SUCCESS; -} + } -static HB_ERRCODE sqlbaseSetFilter( SQLBASEAREAP pArea, LPDBFILTERINFO pFilterInfo ) -{ + static HB_ERRCODE sqlbaseSetFilter( SQLBASEAREAP pArea, LPDBFILTERINFO pFilterInfo ) + { if ( pArea->lpdbPendingRel ) { if ( SELF_FORCEREL( ( AREAP ) pArea ) != HB_SUCCESS ) return HB_FAILURE; } return SUPER_SETFILTER( ( AREAP ) pArea, pFilterInfo ); -} -*/ + } + */ static HB_ERRCODE sqlbaseInit( LPRDDNODE pRDD ) @@ -917,27 +917,27 @@ static HB_ERRCODE sqlbaseExit( LPRDDNODE pRDD ) HB_SYMBOL_UNUSED( pRDD ); - if ( s_pConnection ) + if( s_pConnection ) { /* Disconnect all connections */ - for ( ul = 0; ul < s_ulConnectionCount; ul++ ) + for( ul = 0; ul < s_ulConnectionCount; ul++ ) { - if ( s_pConnection[ ul ] ) + if( s_pConnection[ ul ] ) { s_pConnection[ ul ]->pSDD->Disconnect( s_pConnection[ ul ] ); hb_xfree( s_pConnection[ ul ] ); } } hb_xfree( s_pConnection ); - s_pConnection = NULL; - s_ulConnectionCount = 0; - s_ulConnectionCurrent = 0; - if ( s_szError ) + s_pConnection = NULL; + s_ulConnectionCount = 0; + s_ulConnectionCurrent = 0; + if( s_szError ) { hb_xfree( s_szError ); s_szError = NULL; } - if ( s_szQuery ) + if( s_szQuery ) { hb_xfree( s_szQuery ); s_szQuery = NULL; @@ -952,13 +952,13 @@ static HB_ERRCODE sqlbaseExit( LPRDDNODE pRDD ) static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem ) { - HB_ULONG ulConn; + HB_ULONG ulConn; SQLDDCONNECTION * pConn; HB_SYMBOL_UNUSED( pRDD ); ulConn = ulConnect ? ulConnect : s_ulConnectionCurrent; - if ( ulConn > 0 && ulConn <= s_ulConnectionCount ) + if( ulConn > 0 && ulConn <= s_ulConnectionCount ) pConn = s_pConnection[ ulConn - 1 ]; else pConn = NULL; @@ -974,12 +974,12 @@ static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ul { HB_ULONG ulNewConnection = 0; - if ( hb_itemType( pItem ) & HB_IT_NUMERIC ) + if( hb_itemType( pItem ) & HB_IT_NUMERIC ) { ulNewConnection = hb_itemGetNL( pItem ); } hb_itemPutNL( pItem, ulConnect ? ulConnect : s_ulConnectionCurrent ); - if ( ulNewConnection ) + if( ulNewConnection ) { s_ulConnectionCurrent = ulNewConnection; } @@ -997,17 +997,17 @@ static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ul case RDDI_CONNECT: { - PSDDNODE pNode = NULL; - HB_ULONG ul; - const char * pStr; + PSDDNODE pNode = NULL; + HB_ULONG ul; + const char * pStr; pStr = hb_arrayGetCPtr( pItem, 1 ); - if ( pStr ) + if( pStr ) { pNode = s_pSdd; - while ( pNode ) + while( pNode ) { - if ( ! hb_stricmp( pNode->Name, pStr ) ) + if( ! hb_stricmp( pNode->Name, pStr ) ) break; pNode = pNode->pNext; } @@ -1015,32 +1015,32 @@ static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ul hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 ); pConn = ( SQLDDCONNECTION * ) hb_xgrab( sizeof( SQLDDCONNECTION ) ); - memset( pConn, 0, sizeof( SQLDDCONNECTION ) ); - if ( pNode && pNode->Connect( pConn, pItem ) == HB_SUCCESS ) + memset( pConn, 0, sizeof( SQLDDCONNECTION ) ); + if( pNode && pNode->Connect( pConn, pItem ) == HB_SUCCESS ) { pConn->pSDD = pNode; /* Find free connection handle */ - for ( ul = 0; ul < s_ulConnectionCount; ul++ ) + for( ul = 0; ul < s_ulConnectionCount; ul++ ) { - if ( ! s_pConnection[ ul ] ) + if( ! s_pConnection[ ul ] ) break; } - if ( ul >= s_ulConnectionCount ) + if( ul >= s_ulConnectionCount ) { /* Realloc connection table */ - if ( s_pConnection ) + if( s_pConnection ) s_pConnection = ( SQLDDCONNECTION ** ) hb_xrealloc( s_pConnection, sizeof( SQLDDCONNECTION * ) * ( s_ulConnectionCount + CONNECTION_LIST_EXPAND ) ); else s_pConnection = ( SQLDDCONNECTION ** ) hb_xgrab( sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND ); - + memset( s_pConnection + s_ulConnectionCount, 0, sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND ); - ul = s_ulConnectionCount; - s_ulConnectionCount += CONNECTION_LIST_EXPAND; + ul = s_ulConnectionCount; + s_ulConnectionCount += CONNECTION_LIST_EXPAND; } - s_pConnection[ ul ] = pConn; + s_pConnection[ ul ] = pConn; ul++; - s_ulConnectionCurrent = ul; + s_ulConnectionCurrent = ul; } else { @@ -1053,9 +1053,8 @@ static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ul } case RDDI_DISCONNECT: - { hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 ); - if ( pConn && ! pConn->uiAreaCount && pConn->pSDD->Disconnect( pConn ) == HB_SUCCESS ) + if( pConn && ! pConn->uiAreaCount && pConn->pSDD->Disconnect( pConn ) == HB_SUCCESS ) { hb_xfree( pConn ); s_pConnection[ ulConn - 1 ] = NULL; @@ -1068,53 +1067,40 @@ static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ul } hb_itemPutL( pItem, HB_FALSE ); return HB_SUCCESS; - } case RDDI_EXECUTE: - { hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 ); - if ( pConn ) + if( pConn ) hb_itemPutL( pItem, pConn->pSDD->Execute( pConn, pItem ) == HB_SUCCESS ); else hb_itemPutL( pItem, HB_FALSE ); return HB_SUCCESS; - } case RDDI_ERROR: - { hb_itemPutC( pItem, s_szError ); return HB_SUCCESS; - } case RDDI_ERRORNO: - { hb_itemPutNI( pItem, s_errCode ); return HB_SUCCESS; - } case RDDI_QUERY: - { hb_itemPutC( pItem, s_szQuery ); return HB_SUCCESS; - } case RDDI_NEWID: - { hb_itemCopy( pItem, s_pItemNewID ); return HB_SUCCESS; - } case RDDI_AFFECTEDROWS: - { hb_itemPutNInt( pItem, s_ulAffectedRows ); return HB_SUCCESS; - } /* default: return SUPER_RDDINFO( pRDD, uiIndex, ulConnect, pItem ); -*/ + */ } @@ -1126,131 +1112,134 @@ static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ul static RDDFUNCS sqlbaseTable = { - ( DBENTRYP_BP ) NULL, /* sqlbaseBof */ - ( DBENTRYP_BP ) NULL, /* sqlbaseEof */ - ( DBENTRYP_BP ) NULL, /* sqlbaseFound */ - ( DBENTRYP_V ) sqlbaseGoBottom, - ( DBENTRYP_UL ) sqlbaseGoTo, - ( DBENTRYP_I ) sqlbaseGoToId, - ( DBENTRYP_V ) sqlbaseGoTop, - ( DBENTRYP_BIB ) NULL, /* sqlbaseSeek */ - ( DBENTRYP_L ) sqlbaseSkip, - ( DBENTRYP_L ) NULL, /* sqlbaseSkipFilter */ - ( DBENTRYP_L ) sqlbaseSkipRaw, - ( DBENTRYP_VF ) NULL, /* sqlbaseAddField */ - ( DBENTRYP_B ) sqlbaseAppend, - ( DBENTRYP_I ) NULL, /* sqlbaseCreateFields */ - ( DBENTRYP_V ) sqlbaseDeleteRec, - ( DBENTRYP_BP ) sqlbaseDeleted, - ( DBENTRYP_SP ) NULL, /* sqlbaseFieldCount */ - ( DBENTRYP_VF ) NULL, /* sqlbaseFieldDisplay */ - ( DBENTRYP_SSI ) NULL, /* sqlbaseFieldInfo */ - ( DBENTRYP_SCP ) NULL, /* sqlbaseFieldName */ - ( DBENTRYP_V ) NULL, /* sqlbaseFlush */ - ( DBENTRYP_PP ) NULL, /* sqlbaseGetRec */ - ( DBENTRYP_SI ) sqlbaseGetValue, - ( DBENTRYP_SVL ) sqlbaseGetVarLen, - ( DBENTRYP_V ) sqlbaseGoCold, - ( DBENTRYP_V ) sqlbaseGoHot, - ( DBENTRYP_P ) NULL, /* sqlbasePutRec */ - ( DBENTRYP_SI ) sqlbasePutValue, - ( DBENTRYP_V ) sqlbaseRecall, - ( DBENTRYP_ULP ) sqlbaseRecCount, - ( DBENTRYP_ISI ) NULL, /* sqlbaseRecInfo */ - ( DBENTRYP_ULP ) sqlbaseRecNo, - ( DBENTRYP_I ) sqlbaseRecId, - ( DBENTRYP_S ) NULL, /* sqlbaseSetFieldExtent */ - ( DBENTRYP_CP ) NULL, /* sqlbaseAlias */ - ( DBENTRYP_V ) sqlbaseClose, - ( DBENTRYP_VO ) sqlbaseCreate, - ( DBENTRYP_SI ) sqlbaseInfo, - ( DBENTRYP_V ) NULL, /* sqlbaseNewArea */ - ( DBENTRYP_VO ) sqlbaseOpen, - ( DBENTRYP_V ) NULL, /* sqlbaseRelease */ - ( DBENTRYP_SP ) sqlbaseStructSize, - ( DBENTRYP_CP ) NULL, /* sqlbaseSysName */ - ( DBENTRYP_VEI ) NULL, /* sqlbaseEval */ - ( DBENTRYP_V ) NULL, /* sqlbasePack */ - ( DBENTRYP_LSP ) NULL, /* sqlbasePackRec */ - ( DBENTRYP_VS ) NULL, /* sqlbaseSort */ - ( DBENTRYP_VT ) NULL, /* sqlbaseTrans */ - ( DBENTRYP_VT ) NULL, /* sqlbaseTransRec */ - ( DBENTRYP_V ) NULL, /* sqlbaseZap */ - ( DBENTRYP_VR ) NULL, /* sqlbaseChildEnd */ - ( DBENTRYP_VR ) NULL, /* sqlbaseChildStart */ - ( DBENTRYP_VR ) NULL, /* sqlbaseChildSync */ - ( DBENTRYP_V ) NULL, /* sqlbaseSyncChildren */ - ( DBENTRYP_V ) NULL, /* sqlbaseClearRel */ - ( DBENTRYP_V ) NULL, /* sqlbaseForceRel */ - ( DBENTRYP_SSP ) NULL, /* sqlbaseRelArea */ - ( DBENTRYP_VR ) NULL, /* sqlbaseRelEval */ - ( DBENTRYP_SI ) NULL, /* sqlbaseRelText */ - ( DBENTRYP_VR ) NULL, /* sqlbaseSetRel */ - ( DBENTRYP_VOI ) NULL, /* sqlbaseOrderListAdd */ - ( DBENTRYP_V ) NULL, /* sqlbaseOrderListClear */ - ( DBENTRYP_VOI ) NULL, /* sqlbaseOrderListDelete */ - ( DBENTRYP_VOI ) NULL, /* sqlbaseOrderListFocus */ - ( DBENTRYP_V ) NULL, /* sqlbaseOrderListRebuild */ - ( DBENTRYP_VOO ) NULL, /* sqlbaseOrderCondition */ - ( DBENTRYP_VOC ) NULL, /* sqlbaseOrderCreate */ - ( DBENTRYP_VOI ) NULL, /* sqlbaseOrderDestroy */ - ( DBENTRYP_SVOI ) NULL, /* sqlbaseOrderInfo */ - ( DBENTRYP_V ) NULL, /* sqlbaseClearFilter */ - ( DBENTRYP_V ) NULL, /* sqlbaseClearLocate */ - ( DBENTRYP_V ) NULL, /* sqlbaseClearScope */ - ( DBENTRYP_VPLP ) NULL, /* sqlbaseCountScope */ - ( DBENTRYP_I ) NULL, /* sqlbaseFilterText */ - ( DBENTRYP_SI ) NULL, /* sqlbaseScopeInfo */ - ( DBENTRYP_VFI ) NULL, /* sqlbaseSetFilter */ - ( DBENTRYP_VLO ) NULL, /* sqlbaseSetLocate */ - ( DBENTRYP_VOS ) NULL, /* sqlbaseSetScope */ - ( DBENTRYP_VPL ) NULL, /* sqlbaseSkipScope */ - ( DBENTRYP_B ) NULL, /* sqlbaseLocate */ - ( DBENTRYP_CC ) NULL, /* sqlbaseCompile */ - ( DBENTRYP_I ) NULL, /* sqlbaseError */ - ( DBENTRYP_I ) NULL, /* sqlbaseEvalBlock */ - ( DBENTRYP_VSP ) NULL, /* sqlbaseRawLock */ - ( DBENTRYP_VL ) NULL, /* sqlbaseLock */ - ( DBENTRYP_I ) NULL, /* sqlbaseUnLock */ - ( DBENTRYP_V ) NULL, /* sqlbaseCloseMemFile */ - ( DBENTRYP_VO ) NULL, /* sqlbaseCreateMemFile */ - ( DBENTRYP_SCCS ) NULL, /* sqlbaseGetValueFile */ - ( DBENTRYP_VO ) NULL, /* sqlbaseOpenMemFile */ - ( DBENTRYP_SCCS ) NULL, /* sqlbasePutValueFile */ - ( DBENTRYP_V ) NULL, /* sqlbaseReadDBHeader */ - ( DBENTRYP_V ) NULL, /* sqlbaseWriteDBHeader */ - ( DBENTRYP_R ) sqlbaseInit, - ( DBENTRYP_R ) sqlbaseExit, - ( DBENTRYP_RVVL ) NULL, /* sqlbaseDrop */ - ( DBENTRYP_RVVL ) NULL, /* sqlbaseExists */ - ( DBENTRYP_RVVVL ) NULL, /* sqlbaseRename */ - ( DBENTRYP_RSLV ) sqlbaseRddInfo, - ( DBENTRYP_SVP ) NULL /* sqlbaseWhoCares */ + ( DBENTRYP_BP ) NULL, /* sqlbaseBof */ + ( DBENTRYP_BP ) NULL, /* sqlbaseEof */ + ( DBENTRYP_BP ) NULL, /* sqlbaseFound */ + ( DBENTRYP_V ) sqlbaseGoBottom, + ( DBENTRYP_UL ) sqlbaseGoTo, + ( DBENTRYP_I ) sqlbaseGoToId, + ( DBENTRYP_V ) sqlbaseGoTop, + ( DBENTRYP_BIB ) NULL, /* sqlbaseSeek */ + ( DBENTRYP_L ) sqlbaseSkip, + ( DBENTRYP_L ) NULL, /* sqlbaseSkipFilter */ + ( DBENTRYP_L ) sqlbaseSkipRaw, + ( DBENTRYP_VF ) NULL, /* sqlbaseAddField */ + ( DBENTRYP_B ) sqlbaseAppend, + ( DBENTRYP_I ) NULL, /* sqlbaseCreateFields */ + ( DBENTRYP_V ) sqlbaseDeleteRec, + ( DBENTRYP_BP ) sqlbaseDeleted, + ( DBENTRYP_SP ) NULL, /* sqlbaseFieldCount */ + ( DBENTRYP_VF ) NULL, /* sqlbaseFieldDisplay */ + ( DBENTRYP_SSI ) NULL, /* sqlbaseFieldInfo */ + ( DBENTRYP_SCP ) NULL, /* sqlbaseFieldName */ + ( DBENTRYP_V ) NULL, /* sqlbaseFlush */ + ( DBENTRYP_PP ) NULL, /* sqlbaseGetRec */ + ( DBENTRYP_SI ) sqlbaseGetValue, + ( DBENTRYP_SVL ) sqlbaseGetVarLen, + ( DBENTRYP_V ) sqlbaseGoCold, + ( DBENTRYP_V ) sqlbaseGoHot, + ( DBENTRYP_P ) NULL, /* sqlbasePutRec */ + ( DBENTRYP_SI ) sqlbasePutValue, + ( DBENTRYP_V ) sqlbaseRecall, + ( DBENTRYP_ULP ) sqlbaseRecCount, + ( DBENTRYP_ISI ) NULL, /* sqlbaseRecInfo */ + ( DBENTRYP_ULP ) sqlbaseRecNo, + ( DBENTRYP_I ) sqlbaseRecId, + ( DBENTRYP_S ) NULL, /* sqlbaseSetFieldExtent */ + ( DBENTRYP_CP ) NULL, /* sqlbaseAlias */ + ( DBENTRYP_V ) sqlbaseClose, + ( DBENTRYP_VO ) sqlbaseCreate, + ( DBENTRYP_SI ) sqlbaseInfo, + ( DBENTRYP_V ) NULL, /* sqlbaseNewArea */ + ( DBENTRYP_VO ) sqlbaseOpen, + ( DBENTRYP_V ) NULL, /* sqlbaseRelease */ + ( DBENTRYP_SP ) sqlbaseStructSize, + ( DBENTRYP_CP ) NULL, /* sqlbaseSysName */ + ( DBENTRYP_VEI ) NULL, /* sqlbaseEval */ + ( DBENTRYP_V ) NULL, /* sqlbasePack */ + ( DBENTRYP_LSP ) NULL, /* sqlbasePackRec */ + ( DBENTRYP_VS ) NULL, /* sqlbaseSort */ + ( DBENTRYP_VT ) NULL, /* sqlbaseTrans */ + ( DBENTRYP_VT ) NULL, /* sqlbaseTransRec */ + ( DBENTRYP_V ) NULL, /* sqlbaseZap */ + ( DBENTRYP_VR ) NULL, /* sqlbaseChildEnd */ + ( DBENTRYP_VR ) NULL, /* sqlbaseChildStart */ + ( DBENTRYP_VR ) NULL, /* sqlbaseChildSync */ + ( DBENTRYP_V ) NULL, /* sqlbaseSyncChildren */ + ( DBENTRYP_V ) NULL, /* sqlbaseClearRel */ + ( DBENTRYP_V ) NULL, /* sqlbaseForceRel */ + ( DBENTRYP_SSP ) NULL, /* sqlbaseRelArea */ + ( DBENTRYP_VR ) NULL, /* sqlbaseRelEval */ + ( DBENTRYP_SI ) NULL, /* sqlbaseRelText */ + ( DBENTRYP_VR ) NULL, /* sqlbaseSetRel */ + ( DBENTRYP_VOI ) NULL, /* sqlbaseOrderListAdd */ + ( DBENTRYP_V ) NULL, /* sqlbaseOrderListClear */ + ( DBENTRYP_VOI ) NULL, /* sqlbaseOrderListDelete */ + ( DBENTRYP_VOI ) NULL, /* sqlbaseOrderListFocus */ + ( DBENTRYP_V ) NULL, /* sqlbaseOrderListRebuild */ + ( DBENTRYP_VOO ) NULL, /* sqlbaseOrderCondition */ + ( DBENTRYP_VOC ) NULL, /* sqlbaseOrderCreate */ + ( DBENTRYP_VOI ) NULL, /* sqlbaseOrderDestroy */ + ( DBENTRYP_SVOI ) NULL, /* sqlbaseOrderInfo */ + ( DBENTRYP_V ) NULL, /* sqlbaseClearFilter */ + ( DBENTRYP_V ) NULL, /* sqlbaseClearLocate */ + ( DBENTRYP_V ) NULL, /* sqlbaseClearScope */ + ( DBENTRYP_VPLP ) NULL, /* sqlbaseCountScope */ + ( DBENTRYP_I ) NULL, /* sqlbaseFilterText */ + ( DBENTRYP_SI ) NULL, /* sqlbaseScopeInfo */ + ( DBENTRYP_VFI ) NULL, /* sqlbaseSetFilter */ + ( DBENTRYP_VLO ) NULL, /* sqlbaseSetLocate */ + ( DBENTRYP_VOS ) NULL, /* sqlbaseSetScope */ + ( DBENTRYP_VPL ) NULL, /* sqlbaseSkipScope */ + ( DBENTRYP_B ) NULL, /* sqlbaseLocate */ + ( DBENTRYP_CC ) NULL, /* sqlbaseCompile */ + ( DBENTRYP_I ) NULL, /* sqlbaseError */ + ( DBENTRYP_I ) NULL, /* sqlbaseEvalBlock */ + ( DBENTRYP_VSP ) NULL, /* sqlbaseRawLock */ + ( DBENTRYP_VL ) NULL, /* sqlbaseLock */ + ( DBENTRYP_I ) NULL, /* sqlbaseUnLock */ + ( DBENTRYP_V ) NULL, /* sqlbaseCloseMemFile */ + ( DBENTRYP_VO ) NULL, /* sqlbaseCreateMemFile */ + ( DBENTRYP_SCCS ) NULL, /* sqlbaseGetValueFile */ + ( DBENTRYP_VO ) NULL, /* sqlbaseOpenMemFile */ + ( DBENTRYP_SCCS ) NULL, /* sqlbasePutValueFile */ + ( DBENTRYP_V ) NULL, /* sqlbaseReadDBHeader */ + ( DBENTRYP_V ) NULL, /* sqlbaseWriteDBHeader */ + ( DBENTRYP_R ) sqlbaseInit, + ( DBENTRYP_R ) sqlbaseExit, + ( DBENTRYP_RVVL ) NULL, /* sqlbaseDrop */ + ( DBENTRYP_RVVL ) NULL, /* sqlbaseExists */ + ( DBENTRYP_RVVVL ) NULL, /* sqlbaseRename */ + ( DBENTRYP_RSLV ) sqlbaseRddInfo, + ( DBENTRYP_SVP ) NULL /* sqlbaseWhoCares */ }; /*================ Module initialization code ========================================*/ -HB_FUNC( SQLBASE ) {;} +HB_FUNC( SQLBASE ) +{ + ; +} HB_FUNC_STATIC( SQLBASE_GETFUNCTABLE ) { - RDDFUNCS * pTable; + RDDFUNCS * pTable; HB_USHORT * puiCount, uiRddId; puiCount = ( HB_USHORT * ) hb_parptr( 1 ); - pTable = ( RDDFUNCS * ) hb_parptr( 2 ); - uiRddId = ( HB_USHORT ) hb_parni( 4 ); + pTable = ( RDDFUNCS * ) hb_parptr( 2 ); + uiRddId = ( HB_USHORT ) hb_parni( 4 ); - if ( pTable ) + if( pTable ) { HB_ERRCODE errCode; if( puiCount ) - * puiCount = RDDFUNCSCOUNT; + *puiCount = RDDFUNCSCOUNT; errCode = hb_rddInheritEx( pTable, &sqlbaseTable, &sqlbaseSuper, NULL, NULL ); - if ( errCode == HB_SUCCESS ) + if( errCode == HB_SUCCESS ) { s_rddidSQLBASE = uiRddId; } @@ -1266,24 +1255,26 @@ static void hb_sqlbaseInit( void * cargo ) { HB_SYMBOL_UNUSED( cargo ); - if ( hb_rddRegister( "SQLBASE", RDT_FULL ) > 1 ) + if( hb_rddRegister( "SQLBASE", RDT_FULL ) > 1 ) hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL ); } HB_INIT_SYMBOLS_BEGIN( sqlbase__InitSymbols ) -{ "SQLBASE", {HB_FS_PUBLIC}, {HB_FUNCNAME( SQLBASE )}, NULL }, -{ "SQLBASE_GETFUNCTABLE", {HB_FS_PUBLIC}, {HB_FUNCNAME( SQLBASE_GETFUNCTABLE )}, NULL } +{ + "SQLBASE", { HB_FS_PUBLIC }, { HB_FUNCNAME( SQLBASE ) }, NULL +}, +{ "SQLBASE_GETFUNCTABLE", { HB_FS_PUBLIC }, { HB_FUNCNAME( SQLBASE_GETFUNCTABLE ) }, NULL } HB_INIT_SYMBOLS_END( sqlbase__InitSymbols ) HB_CALL_ON_STARTUP_BEGIN( _hb_sqlbase_init_ ) - hb_vmAtInit( hb_sqlbaseInit, NULL ); +hb_vmAtInit( hb_sqlbaseInit, NULL ); HB_CALL_ON_STARTUP_END( _hb_sqlbase_init_ ) #if defined( HB_PRAGMA_STARTUP ) #pragma startup sqlbase__InitSymbols #pragma startup _hb_sqlbase_init_ #elif defined( HB_DATASEG_STARTUP ) - #define HB_DATASEG_BODY HB_DATASEG_FUNC( sqlbase__InitSymbols ) \ - HB_DATASEG_FUNC( _hb_sqlbase_init_ ) + #define HB_DATASEG_BODY HB_DATASEG_FUNC( sqlbase__InitSymbols ) \ + HB_DATASEG_FUNC( _hb_sqlbase_init_ ) #include "hbiniseg.h" #endif diff --git a/harbour/contrib/rddsql/sqlmix.c b/harbour/contrib/rddsql/sqlmix.c index 11a562311b..8641c1d227 100644 --- a/harbour/contrib/rddsql/sqlmix.c +++ b/harbour/contrib/rddsql/sqlmix.c @@ -68,57 +68,57 @@ #define MIX_KEY( tag, node, index ) \ - ( ( PMIXKEY ) & ( ( HB_BYTE * ) (node) ) [ ( (node)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (index) * (tag)->uiTotalLen ] ) + ( ( PMIXKEY ) &( ( HB_BYTE * ) ( node ) )[ ( ( node )->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + ( index ) * ( tag )->uiTotalLen ] ) #define MIX_COPY_KEYS_INTERNAL( tag, node, dst, src, count ) \ - memmove( ( ( HB_BYTE * ) (node) ) + ( (node)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (dst) * (tag)->uiTotalLen, \ - ( ( HB_BYTE * ) (node) ) + ( (node)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (src) * (tag)->uiTotalLen, \ - (count) * (tag)->uiTotalLen ) + memmove( ( ( HB_BYTE * ) ( node ) ) + ( ( node )->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + ( dst ) * ( tag )->uiTotalLen, \ + ( ( HB_BYTE * ) ( node ) ) + ( ( node )->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + ( src ) * ( tag )->uiTotalLen, \ + ( count ) * ( tag )->uiTotalLen ) #define MIX_COPY_KEYS_EXTERNAL( tag, ndst, dst, nsrc, src, count ) \ - memmove( ( ( HB_BYTE * ) (ndst) ) + ( (ndst)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (dst) * (tag)->uiTotalLen, \ - ( ( HB_BYTE * ) (nsrc) ) + ( (nsrc)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (src) * (tag)->uiTotalLen, \ - (count) * (tag)->uiTotalLen ) + memmove( ( ( HB_BYTE * ) ( ndst ) ) + ( ( ndst )->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + ( dst ) * ( tag )->uiTotalLen, \ + ( ( HB_BYTE * ) ( nsrc ) ) + ( ( nsrc )->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + ( src ) * ( tag )->uiTotalLen, \ + ( count ) * ( tag )->uiTotalLen ) #define MIX_ASSIGN_KEY( tag, node, dst, src ) \ - memmove( ( ( HB_BYTE * ) (node) ) + ( (node)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (dst) * (tag)->uiTotalLen, \ - (src), (tag)->uiTotalLen ) + memmove( ( ( HB_BYTE * ) ( node ) ) + ( ( node )->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + ( dst ) * ( tag )->uiTotalLen, \ + ( src ), ( tag )->uiTotalLen ) #define MIX_COPY_CHILDS_INTERNAL( tag, node, dst, src, count ) \ - memmove( & ((node)->Child[ (dst) ]), & ((node)->Child[ (src) ]), (count) * sizeof( void * ) ) + memmove( &( ( node )->Child[ ( dst ) ] ), &( ( node )->Child[ ( src ) ] ), ( count ) * sizeof( void * ) ) #define MIX_COPY_CHILDS_EXTERNAL( tag, ndst, dst, nsrc, src, count ) \ - memmove( & ((ndst)->Child[ (dst) ]), & ((nsrc)->Child[ (src) ]), (count) * sizeof( void * ) ) + memmove( &( ( ndst )->Child[ ( dst ) ] ), &( ( nsrc )->Child[ ( src ) ] ), ( count ) * sizeof( void * ) ) -static HB_USHORT s_uiRddIdSQLMIX = ( HB_USHORT ) -1; +static HB_USHORT s_uiRddIdSQLMIX = ( HB_USHORT ) -1; -static RDDFUNCS sqlmixSuper; +static RDDFUNCS sqlmixSuper; /* -======================================================================= - Misc functions -======================================================================= -*/ + ======================================================================= + Misc functions + ======================================================================= + */ static HB_ERRCODE sqlmixErrorRT( SQLMIXAREAP pArea, HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, char * filename, HB_ERRCODE errOsCode, HB_USHORT uiFlags ) { - PHB_ITEM pError; - HB_ERRCODE iRet = HB_FAILURE; + PHB_ITEM pError; + HB_ERRCODE iRet = HB_FAILURE; - if ( hb_vmRequestQuery() == 0 ) + if( hb_vmRequestQuery() == 0 ) { pError = hb_errNew(); hb_errPutGenCode( pError, errGenCode ); hb_errPutSubCode( pError, errSubCode ); hb_errPutOsCode( pError, errOsCode ); hb_errPutDescription( pError, hb_langDGetErrorDesc( errGenCode ) ); - if ( filename ) + if( filename ) hb_errPutFileName( pError, filename ); - if ( uiFlags ) + if( uiFlags ) hb_errPutFlags( pError, uiFlags ); iRet = SELF_ERROR( ( AREAP ) pArea, pError ); hb_errRelease( pError ); @@ -128,44 +128,44 @@ static HB_ERRCODE sqlmixErrorRT( SQLMIXAREAP pArea, HB_ERRCODE errGenCode, HB_ER /* -======================================================================= - Memory Index -======================================================================= -*/ + ======================================================================= + Memory Index + ======================================================================= + */ /* -------------------------- Key management ---------------------------- */ /* hb_mixKey*() */ static PMIXKEY hb_mixKeyNew( PMIXTAG pTag ) { - return (PMIXKEY) hb_xgrab( pTag->uiTotalLen ); + return ( PMIXKEY ) hb_xgrab( pTag->uiTotalLen ); } static PMIXKEY hb_mixKeyPutItem( PMIXKEY pKey, PHB_ITEM pItem, HB_ULONG ulRecNo, PMIXTAG pTag ) { - double dbl; - HB_BYTE buf[ 8 ]; + double dbl; + HB_BYTE buf[ 8 ]; - if ( ! pKey ) + if( ! pKey ) pKey = hb_mixKeyNew( pTag ); - pKey->rec = ulRecNo; - pKey->notnul = 1; + pKey->rec = ulRecNo; + pKey->notnul = 1; /* TODO: check valtype */ - switch ( pTag->bType ) + switch( pTag->bType ) { case 'C': { HB_SIZE ul = hb_itemGetCLen( pItem ); - if ( ul > ( HB_SIZE ) pTag->uiKeyLen ) + if( ul > ( HB_SIZE ) pTag->uiKeyLen ) ul = pTag->uiKeyLen; memcpy( pKey->val, hb_itemGetCPtr( pItem ), ul ); - if ( ul < ( HB_SIZE ) pTag->uiKeyLen ) + if( ul < ( HB_SIZE ) pTag->uiKeyLen ) memset( pKey->val + ul, ' ', ( HB_SIZE ) pTag->uiKeyLen - ul ); break; @@ -196,21 +196,21 @@ static PMIXKEY hb_mixKeyPutItem( PMIXKEY pKey, PHB_ITEM pItem, HB_ULONG ulRecNo, static PMIXKEY hb_mixKeyEval( PMIXKEY pKey, PMIXTAG pTag ) { - PHB_ITEM pItem; - SQLMIXAREAP pArea = pTag->pArea; - int iCurrArea = hb_rddGetCurrentWorkAreaNumber(); - PHB_CODEPAGE pCodepage = hb_cdpSelect( pArea->sqlarea.area.cdPage ); + PHB_ITEM pItem; + SQLMIXAREAP pArea = pTag->pArea; + int iCurrArea = hb_rddGetCurrentWorkAreaNumber(); + PHB_CODEPAGE pCodepage = hb_cdpSelect( pArea->sqlarea.area.cdPage ); - if ( iCurrArea != pArea->sqlarea.area.uiArea ) + if( iCurrArea != pArea->sqlarea.area.uiArea ) hb_rddSelectWorkAreaNumber( pArea->sqlarea.area.uiArea ); else iCurrArea = 0; pItem = hb_vmEvalBlockOrMacro( pTag->pKeyItem ); - pKey = hb_mixKeyPutItem( pKey, pItem, pArea->sqlarea.ulRecNo, pTag ); + pKey = hb_mixKeyPutItem( pKey, pItem, pArea->sqlarea.ulRecNo, pTag ); - if ( iCurrArea ) + if( iCurrArea ) hb_rddSelectWorkAreaNumber( iCurrArea ); hb_cdpSelect( pCodepage ); @@ -221,14 +221,14 @@ static PMIXKEY hb_mixKeyEval( PMIXKEY pKey, PMIXTAG pTag ) static HB_BOOL hb_mixEvalCond( SQLMIXAREAP pArea, PHB_ITEM pCondItem ) { - int iCurrArea = 0; - HB_BOOL fRet; + int iCurrArea = 0; + HB_BOOL fRet; - if ( pArea ) + if( pArea ) { iCurrArea = hb_rddGetCurrentWorkAreaNumber(); - if ( iCurrArea != pArea->sqlarea.area.uiArea ) + if( iCurrArea != pArea->sqlarea.area.uiArea ) hb_rddSelectWorkAreaNumber( pArea->sqlarea.area.uiArea ); else iCurrArea = 0; @@ -236,7 +236,7 @@ static HB_BOOL hb_mixEvalCond( SQLMIXAREAP pArea, PHB_ITEM pCondItem ) fRet = hb_itemGetL( hb_vmEvalBlockOrMacro( pCondItem ) ); - if ( iCurrArea ) + if( iCurrArea ) hb_rddSelectWorkAreaNumber( iCurrArea ); return fRet; @@ -251,59 +251,59 @@ static void hb_mixKeyFree( PMIXKEY pKey ) static int hb_mixKeyCompare( PMIXTAG pTag, PMIXKEY pKey1, PMIXKEY pKey2, unsigned int uiLen ) { - unsigned int uiSize; - int i; + unsigned int uiSize; + int i; - if ( ! pKey1->notnul || ! pKey2->notnul ) + if( ! pKey1->notnul || ! pKey2->notnul ) { return ( int ) pKey1->notnul - ( int ) pKey2->notnul; } - i = 0; - uiSize = pTag->uiKeyLen > uiLen ? uiLen : pTag->uiKeyLen; + i = 0; + uiSize = pTag->uiKeyLen > uiLen ? uiLen : pTag->uiKeyLen; - if ( pTag->pCodepage ) + if( pTag->pCodepage ) { i = hb_cdpcmp( ( const char * ) pKey1->val, ( HB_SIZE ) uiSize, ( const char * ) pKey2->val, ( HB_SIZE ) uiSize, pTag->pCodepage, 0 ); } else { - if ( uiSize > 0 ) + if( uiSize > 0 ) i = memcmp( pKey1->val, pKey2->val, uiSize ); } - if ( i == 0 ) + if( i == 0 ) { - if ( pKey2->rec == ( HB_ULONG ) -1 ) + if( pKey2->rec == ( HB_ULONG ) -1 ) { /* This condition seems inverted, but it's ok for seek last */ - if ( pTag->uiKeyLen > uiLen ) + if( pTag->uiKeyLen > uiLen ) i = -1; } else { - if ( pTag->uiKeyLen > uiLen ) + if( pTag->uiKeyLen > uiLen ) i = 1; - else if ( pTag->uiKeyLen < uiLen ) + else if( pTag->uiKeyLen < uiLen ) i = -1; } } - if ( i != 0 ) + if( i != 0 ) { - if ( i < 0 ) + if( i < 0 ) { return -2; } return 2; } - if ( pKey1->rec < pKey2->rec ) + if( pKey1->rec < pKey2->rec ) { return -1; } - else if ( pKey1->rec > pKey2->rec ) + else if( pKey1->rec > pKey2->rec ) { return 1; } @@ -315,8 +315,8 @@ static int hb_mixKeyCompare( PMIXTAG pTag, PMIXKEY pKey1, PMIXKEY pKey2, unsigne /* hb_mixTag*() */ /* This function is used for debugging purposes. Uncomment it, if you need it. -static void hb_mixTagPrintNode( PMIXTAG pTag, PMIXNODE pNode, int iLevel ) -{ + static void hb_mixTagPrintNode( PMIXTAG pTag, PMIXNODE pNode, int iLevel ) + { unsigned int i; if ( !pNode ) @@ -347,17 +347,17 @@ static void hb_mixTagPrintNode( PMIXTAG pTag, PMIXNODE pNode, int iLevel ) hb_mixTagPrintNode( pTag, pNode->Child[ pNode->KeyCount ], iLevel + 1 ); } -} -*/ + } + */ static PMIXNODE hb_mixTagCreateNode( PMIXTAG pTag, HB_BOOL fLeaf ) { - PMIXNODE pNode; - HB_SIZE ulSize; + PMIXNODE pNode; + HB_SIZE ulSize; - ulSize = ( fLeaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + MIX_NODE_ORDER * pTag->uiTotalLen; + ulSize = ( fLeaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + MIX_NODE_ORDER * pTag->uiTotalLen; - pNode = (PMIXNODE) hb_xgrab( ulSize ); + pNode = ( PMIXNODE ) hb_xgrab( ulSize ); memset( pNode, 0, ulSize ); pNode->Leaf = fLeaf ? 1 : 0; return pNode; @@ -366,61 +366,63 @@ static PMIXNODE hb_mixTagCreateNode( PMIXTAG pTag, HB_BOOL fLeaf ) static unsigned int hb_mixTagNodeParentIndex( PMIXNODE pNode ) { - PMIXNODE pParent = pNode->Parent; - unsigned int ui; + PMIXNODE pParent = pNode->Parent; + unsigned int ui; /* Find position in the parent node */ ui = pParent->KeyCount; - do { - if ( pParent->Child[ ui ] == pNode ) + do + { + if( pParent->Child[ ui ] == pNode ) return ui; - } while ( ui-- ); + } + while( ui-- ); return ( unsigned int ) -1; } -static int hb_mixTagFindKey( PMIXTAG pTag, PMIXKEY pKey, unsigned int uiLen, PMIXNODE* ppNode, unsigned int* puiPos, HB_BOOL fValidKey ) +static int hb_mixTagFindKey( PMIXTAG pTag, PMIXKEY pKey, unsigned int uiLen, PMIXNODE * ppNode, unsigned int * puiPos, HB_BOOL fValidKey ) { - PMIXNODE pNode; - unsigned int ui; - int i; + PMIXNODE pNode; + unsigned int ui; + int i; pNode = pTag->Root; - while ( 1 ) + while( 1 ) { i = -2; /* TODO: binary search */ - for ( ui = 0; ui < pNode->KeyCount; ui++ ) + for( ui = 0; ui < pNode->KeyCount; ui++ ) { i = hb_mixKeyCompare( pTag, MIX_KEY( pTag, pNode, ui ), pKey, uiLen ); - if ( i >= 0 ) + if( i >= 0 ) { break; } } - if ( i == 0 || pNode->Leaf ) + if( i == 0 || pNode->Leaf ) break; else pNode = pNode->Child[ ui ]; } - if ( fValidKey && ui >= pNode->KeyCount ) + if( fValidKey && ui >= pNode->KeyCount ) { /* unsuccessful find always finds position in leaf */ - while ( pNode->Parent && pNode->Parent->Child[ pNode->Parent->KeyCount ] == pNode ) + while( pNode->Parent && pNode->Parent->Child[ pNode->Parent->KeyCount ] == pNode ) pNode = pNode->Parent; - if ( pNode->Parent ) + if( pNode->Parent ) { - for ( ui = 0; ui < pNode->Parent->KeyCount; ui++ ) + for( ui = 0; ui < pNode->Parent->KeyCount; ui++ ) { - if ( pNode->Parent->Child[ ui ] == pNode ) + if( pNode->Parent->Child[ ui ] == pNode ) { pNode = pNode->Parent; break; @@ -433,20 +435,20 @@ static int hb_mixTagFindKey( PMIXTAG pTag, PMIXKEY pKey, unsigned int uiLen, PMI } } - * ppNode = pNode; - * puiPos = ui; + *ppNode = pNode; + *puiPos = ui; return i; } static void hb_mixTagSetCurrent( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPos ) { - if ( uiPos < pNode->KeyCount ) + if( uiPos < pNode->KeyCount ) { - pTag->CurNode = pNode; - pTag->CurPos = uiPos; - pTag->CurKey = MIX_KEY( pTag, pNode, uiPos ); - pTag->fEof = HB_FALSE; + pTag->CurNode = pNode; + pTag->CurPos = uiPos; + pTag->CurKey = MIX_KEY( pTag, pNode, uiPos ); + pTag->fEof = HB_FALSE; } else { @@ -457,23 +459,23 @@ static void hb_mixTagSetCurrent( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPo static HB_BOOL hb_mixTagRefreshKey( PMIXTAG pTag ) { - SQLMIXAREAP pArea; + SQLMIXAREAP pArea; pArea = pTag->pArea; - if ( pArea->sqlarea.lpdbPendingRel ) + if( pArea->sqlarea.lpdbPendingRel ) SELF_FORCEREL( ( AREAP ) pArea ); - if ( ! pArea->sqlarea.fPositioned ) + if( ! pArea->sqlarea.fPositioned ) { pTag->fEof = HB_TRUE; return HB_FALSE; } - else if ( pTag->fEof || pTag->CurKey->rec != pArea->sqlarea.ulRecNo ) + else if( pTag->fEof || pTag->CurKey->rec != pArea->sqlarea.ulRecNo ) { - PMIXKEY pKey; - PMIXNODE pNode; - unsigned int ui; + PMIXKEY pKey; + PMIXNODE pNode; + unsigned int ui; pKey = hb_mixKeyEval( NULL, pTag ); @@ -491,13 +493,13 @@ static HB_BOOL hb_mixTagRefreshKey( PMIXTAG pTag ) static void hb_mixTagAddKeyNode( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPos, PMIXKEY pKey, PMIXNODE pChildLeft, PMIXNODE pChildRight ) { MIX_COPY_KEYS_INTERNAL( pTag, pNode, uiPos + 1, uiPos, pNode->KeyCount - uiPos ); - if ( ! pNode->Leaf ) + if( ! pNode->Leaf ) { MIX_COPY_CHILDS_INTERNAL( pTag, pNode, uiPos + 2, uiPos + 1, pNode->KeyCount - uiPos ); - pNode->Child[ uiPos ] = pChildLeft; - pNode->Child[ uiPos + 1 ] = pChildRight; - pChildLeft->Parent = pNode; - pChildRight->Parent = pNode; + pNode->Child[ uiPos ] = pChildLeft; + pNode->Child[ uiPos + 1 ] = pChildRight; + pChildLeft->Parent = pNode; + pChildRight->Parent = pNode; } MIX_ASSIGN_KEY( pTag, pNode, uiPos, pKey ); pNode->KeyCount++; @@ -506,10 +508,10 @@ static void hb_mixTagAddKeyNode( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPo static void hb_mixTagAddKeyPos( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPos, PMIXKEY pKey, PMIXNODE pChildLeft, PMIXNODE pChildRight ) { - PMIXNODE pNewNode; - unsigned int j, k; + PMIXNODE pNewNode; + unsigned int j, k; - if ( pNode->KeyCount < MIX_NODE_ORDER ) + if( pNode->KeyCount < MIX_NODE_ORDER ) { hb_mixTagAddKeyNode( pTag, pNode, uiPos, pKey, pChildLeft, pChildRight ); return; @@ -518,48 +520,48 @@ static void hb_mixTagAddKeyPos( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPos #ifdef USE_SIBLINGS /* Try use siblings, if leaf node is full */ - if ( pNode->Leaf && pNode->Parent ) + if( pNode->Leaf && pNode->Parent ) { - j = hb_mixTagNodeParentIndex( pNode ); + j = hb_mixTagNodeParentIndex( pNode ); - if ( j > 0 && pNode->Parent->Child[ j - 1 ]->KeyCount < MIX_NODE_ORDER ) - { - MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent->Child[ j - 1 ], pNode->Parent->Child[ j - 1 ]->KeyCount, pNode->Parent, j - 1, 1 ); - pNode->Parent->Child[ j - 1 ]->KeyCount++; + if( j > 0 && pNode->Parent->Child[ j - 1 ]->KeyCount < MIX_NODE_ORDER ) + { + MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent->Child[ j - 1 ], pNode->Parent->Child[ j - 1 ]->KeyCount, pNode->Parent, j - 1, 1 ); + pNode->Parent->Child[ j - 1 ]->KeyCount++; - if ( uiPos == 0 ) - { - MIX_ASSIGN_KEY( pTag, pNode->Parent, j - 1, pKey ); - pNode->Parent->Key[ j - 1 ] = pKey; - } - else - { - MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent, j - 1, pNode, 0 , 1 ); - uiPos--; - MIX_COPY_KEYS_INTERNAL( pTag, pNode, 0, 1, uiPos ); - MIX_ASSIGN_KEY( pTag, pNode, uiPos, pKey ); - } + if( uiPos == 0 ) + { + MIX_ASSIGN_KEY( pTag, pNode->Parent, j - 1, pKey ); + pNode->Parent->Key[ j - 1 ] = pKey; + } + else + { + MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent, j - 1, pNode, 0, 1 ); + uiPos--; + MIX_COPY_KEYS_INTERNAL( pTag, pNode, 0, 1, uiPos ); + MIX_ASSIGN_KEY( pTag, pNode, uiPos, pKey ); + } - return; - } - else if ( j < pNode->Parent->KeyCount && pNode->Parent->Child[ j + 1 ]->KeyCount < MIX_NODE_ORDER ) - { - MIX_COPY_KEYS_INTERNAL( pTag, pNode->Parent->Child[ j + 1 ], 1, 0, pNode->Parent->Child[ j + 1 ]->KeyCount ); - MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent->Child[ j + 1 ], 0, pNode->Parent, j, 1 ); - pNode->Parent->Child[ j + 1 ]->KeyCount++; + return; + } + else if( j < pNode->Parent->KeyCount && pNode->Parent->Child[ j + 1 ]->KeyCount < MIX_NODE_ORDER ) + { + MIX_COPY_KEYS_INTERNAL( pTag, pNode->Parent->Child[ j + 1 ], 1, 0, pNode->Parent->Child[ j + 1 ]->KeyCount ); + MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent->Child[ j + 1 ], 0, pNode->Parent, j, 1 ); + pNode->Parent->Child[ j + 1 ]->KeyCount++; - if ( uiPos == MIX_NODE_ORDER ) - { - MIX_ASSIGN_KEY( pTag, pNode->Parent, j, pKey ); - } - else - { - MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent, j, pNode, MIX_NODE_ORDER - 1, 1 ); - MIX_COPY_KEYS_INTERNAL( pTag, pNode, uiPos + 1, uiPos, MIX_NODE_ORDER - uiPos - 1 ); - MIX_ASSIGN_KEY( pTag, pNode, uiPos, pKey ); - } - return; - } + if( uiPos == MIX_NODE_ORDER ) + { + MIX_ASSIGN_KEY( pTag, pNode->Parent, j, pKey ); + } + else + { + MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent, j, pNode, MIX_NODE_ORDER - 1, 1 ); + MIX_COPY_KEYS_INTERNAL( pTag, pNode, uiPos + 1, uiPos, MIX_NODE_ORDER - uiPos - 1 ); + MIX_ASSIGN_KEY( pTag, pNode, uiPos, pKey ); + } + return; + } } #endif /* USE_SIBLINGS */ @@ -568,38 +570,38 @@ static void hb_mixTagAddKeyPos( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPos pNewNode = hb_mixTagCreateNode( pTag, pNode->Leaf ); /* Move half of items to new node */ - k = MIX_NODE_ORDER / 2 + ( ( uiPos <= MIX_NODE_ORDER / 2 ) ? 0 : 1 ); + k = MIX_NODE_ORDER / 2 + ( ( uiPos <= MIX_NODE_ORDER / 2 ) ? 0 : 1 ); MIX_COPY_KEYS_EXTERNAL( pTag, pNewNode, 0, pNode, k, MIX_NODE_ORDER - k ); - if ( ! pNode->Leaf ) + if( ! pNode->Leaf ) { MIX_COPY_CHILDS_EXTERNAL( pTag, pNewNode, 1, pNode, k + 1, MIX_NODE_ORDER - k ); - for ( j = 1; j <= MIX_NODE_ORDER - k; j++ ) + for( j = 1; j <= MIX_NODE_ORDER - k; j++ ) { pNewNode->Child[ j ]->Parent = pNewNode; /* Do NOT forget to re-parent */ } } - pNode->KeyCount = k; - pNewNode->KeyCount = MIX_NODE_ORDER - k; + pNode->KeyCount = k; + pNewNode->KeyCount = MIX_NODE_ORDER - k; /* Insert new item to the left node or right node */ - if ( uiPos <= MIX_NODE_ORDER / 2 ) + if( uiPos <= MIX_NODE_ORDER / 2 ) hb_mixTagAddKeyNode( pTag, pNode, uiPos, pKey, pChildLeft, pChildRight ); else hb_mixTagAddKeyNode( pTag, pNewNode, uiPos - MIX_NODE_ORDER / 2 - 1, pKey, pChildLeft, pChildRight ); /* Assign the leftmost child of the new node */ - if ( ! pNode->Leaf ) + if( ! pNode->Leaf ) { - pNewNode->Child[ 0 ] = pNode->Child[ pNode->KeyCount ]; - pNewNode->Child[ 0 ]->Parent = pNewNode; + pNewNode->Child[ 0 ] = pNode->Child[ pNode->KeyCount ]; + pNewNode->Child[ 0 ]->Parent = pNewNode; } pNode->KeyCount--; /* Move middle (last+1 in first node) item up */ - if ( pNode->Parent ) + if( pNode->Parent ) { hb_mixTagAddKeyPos( pTag, pNode->Parent, hb_mixTagNodeParentIndex( pNode ), MIX_KEY( pTag, pNode, pNode->KeyCount ), pNode, pNewNode ); @@ -615,14 +617,14 @@ static void hb_mixTagAddKeyPos( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPos static HB_BOOL hb_mixTagAddKey( PMIXTAG pTag, PMIXKEY pKey ) { - PMIXNODE pNode; - unsigned int ui; - int i; + PMIXNODE pNode; + unsigned int ui; + int i; i = hb_mixTagFindKey( pTag, pKey, pTag->uiKeyLen, &pNode, &ui, HB_FALSE ); /* Key can not be duplicated */ - if ( ! i ) + if( ! i ) return HB_FALSE; hb_mixTagAddKeyPos( pTag, pNode, ui, pKey, NULL, NULL ); @@ -633,7 +635,7 @@ static HB_BOOL hb_mixTagAddKey( PMIXTAG pTag, PMIXKEY pKey ) static void hb_mixTagDelKeyNode( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPos ) { MIX_COPY_KEYS_INTERNAL( pTag, pNode, uiPos, uiPos + 1, pNode->KeyCount - uiPos - 1 ); - if ( ! pNode->Leaf ) + if( ! pNode->Leaf ) { MIX_COPY_CHILDS_INTERNAL( pTag, pNode, uiPos, uiPos + 1, pNode->KeyCount - uiPos ); } @@ -643,23 +645,23 @@ static void hb_mixTagDelKeyNode( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPo static void hb_mixTagNodeAdjust( PMIXTAG pTag, PMIXNODE pNode ) { - unsigned int i, j; - PMIXNODE pParent, pSibling; + unsigned int i, j; + PMIXNODE pParent, pSibling; - while ( 1 ) + while( 1 ) { - if ( pNode->KeyCount >= MIX_NODE_ORDER / 2 ) + if( pNode->KeyCount >= MIX_NODE_ORDER / 2 ) return; /* Check siblings */ - if ( pNode->Parent ) + if( pNode->Parent ) { - pParent = pNode->Parent; - j = hb_mixTagNodeParentIndex( pNode ); + pParent = pNode->Parent; + j = hb_mixTagNodeParentIndex( pNode ); - if ( j > 0 && pParent->Child[ j - 1 ]->KeyCount > MIX_NODE_ORDER / 2 ) + if( j > 0 && pParent->Child[ j - 1 ]->KeyCount > MIX_NODE_ORDER / 2 ) { /* Borrow from left */ @@ -671,7 +673,7 @@ static void hb_mixTagNodeAdjust( PMIXTAG pTag, PMIXNODE pNode ) pSibling->KeyCount--; return; } - else if ( j < pParent->KeyCount && pParent->Child[ j + 1 ]->KeyCount > MIX_NODE_ORDER / 2 ) + else if( j < pParent->KeyCount && pParent->Child[ j + 1 ]->KeyCount > MIX_NODE_ORDER / 2 ) { /* Borrow from right */ @@ -681,7 +683,7 @@ static void hb_mixTagNodeAdjust( PMIXTAG pTag, PMIXNODE pNode ) hb_mixTagDelKeyNode( pTag, pSibling, 0 ); return; } - else if ( j > 0 ) + else if( j > 0 ) { /* Join with left */ @@ -690,26 +692,26 @@ static void hb_mixTagNodeAdjust( PMIXTAG pTag, PMIXNODE pNode ) pSibling->KeyCount++; MIX_COPY_KEYS_EXTERNAL( pTag, pSibling, pSibling->KeyCount, pNode, 0, pNode->KeyCount ); - if ( pNode->Leaf ) + if( pNode->Leaf ) { pSibling->KeyCount += pNode->KeyCount; } else { MIX_COPY_CHILDS_EXTERNAL( pTag, pSibling, pSibling->KeyCount, pNode, 0, pNode->KeyCount ); - for ( i = 0; i < pNode->KeyCount; i++ ) + for( i = 0; i < pNode->KeyCount; i++ ) { pSibling->Child[ pSibling->KeyCount++ ]->Parent = pSibling; } - pSibling->Child[ pSibling->KeyCount ] = pNode->Child[ i ]; - pSibling->Child[ pSibling->KeyCount ]->Parent = pSibling; + pSibling->Child[ pSibling->KeyCount ] = pNode->Child[ i ]; + pSibling->Child[ pSibling->KeyCount ]->Parent = pSibling; } hb_xfree( pNode ); - pParent->Child[ j ] = pSibling; + pParent->Child[ j ] = pSibling; hb_mixTagDelKeyNode( pTag, pParent, j - 1 ); - pNode = pParent; + pNode = pParent; } - else if ( j < pParent->KeyCount ) + else if( j < pParent->KeyCount ) { /* Join with right */ @@ -717,34 +719,34 @@ static void hb_mixTagNodeAdjust( PMIXTAG pTag, PMIXNODE pNode ) MIX_COPY_KEYS_EXTERNAL( pTag, pNode, pNode->KeyCount, pParent, j, 1 ); pNode->KeyCount++; MIX_COPY_KEYS_EXTERNAL( pTag, pNode, pNode->KeyCount, pSibling, 0, pSibling->KeyCount ); - if ( pNode->Leaf ) + if( pNode->Leaf ) { pNode->KeyCount += pSibling->KeyCount; } else { MIX_COPY_CHILDS_EXTERNAL( pTag, pNode, pNode->KeyCount, pSibling, 0, pSibling->KeyCount ); - for ( i = 0; i < pSibling->KeyCount; i++ ) + for( i = 0; i < pSibling->KeyCount; i++ ) { pNode->Child[ pNode->KeyCount++ ]->Parent = pNode; } - pNode->Child[ pNode->KeyCount ] = pSibling->Child[ i ]; - pNode->Child[ pNode->KeyCount ]->Parent = pNode; + pNode->Child[ pNode->KeyCount ] = pSibling->Child[ i ]; + pNode->Child[ pNode->KeyCount ]->Parent = pNode; } hb_xfree( pSibling ); pParent->Child[ j + 1 ] = pNode; hb_mixTagDelKeyNode( pTag, pParent, j ); - pNode = pParent; + pNode = pParent; } } else { /* Adjust root */ - if ( ! pNode->KeyCount && ! pNode->Leaf ) + if( ! pNode->KeyCount && ! pNode->Leaf ) { - pTag->Root = pNode->Child[ 0 ]; - pTag->Root->Parent = NULL; + pTag->Root = pNode->Child[ 0 ]; + pTag->Root->Parent = NULL; hb_xfree( pNode ); } return; @@ -755,17 +757,17 @@ static void hb_mixTagNodeAdjust( PMIXTAG pTag, PMIXNODE pNode ) static void hb_mixTagDelKeyPos( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPos ) { - if ( pNode->Leaf ) + if( pNode->Leaf ) { hb_mixTagDelKeyNode( pTag, pNode, uiPos ); hb_mixTagNodeAdjust( pTag, pNode ); } else { - PMIXNODE pLeaf; + PMIXNODE pLeaf; pLeaf = pNode->Child[ uiPos + 1 ]; - while ( ! pLeaf->Leaf ) + while( ! pLeaf->Leaf ) { pLeaf = pLeaf->Child[ 0 ]; } @@ -778,13 +780,13 @@ static void hb_mixTagDelKeyPos( PMIXTAG pTag, PMIXNODE pNode, unsigned int uiPos static HB_BOOL hb_mixTagDelKey( PMIXTAG pTag, PMIXKEY pKey ) { - PMIXNODE pNode; - unsigned int ui; - int i; + PMIXNODE pNode; + unsigned int ui; + int i; i = hb_mixTagFindKey( pTag, pKey, pTag->uiKeyLen, &pNode, &ui, HB_FALSE ); - if ( i ) + if( i ) return HB_FALSE; hb_mixTagDelKeyPos( pTag, pNode, ui ); @@ -792,90 +794,90 @@ static HB_BOOL hb_mixTagDelKey( PMIXTAG pTag, PMIXKEY pKey ) } -static PMIXTAG hb_mixTagCreate( const char* szTagName, PHB_ITEM pKeyExpr, PHB_ITEM pKeyItem, PHB_ITEM pForItem, PHB_ITEM pWhileItem, HB_BYTE bType, unsigned int uiKeyLen, SQLMIXAREAP pArea ) +static PMIXTAG hb_mixTagCreate( const char * szTagName, PHB_ITEM pKeyExpr, PHB_ITEM pKeyItem, PHB_ITEM pForItem, PHB_ITEM pWhileItem, HB_BYTE bType, unsigned int uiKeyLen, SQLMIXAREAP pArea ) { - PMIXTAG pTag; - PMIXKEY pKey = NULL; - LPDBORDERCONDINFO pOrdCondInfo = pArea->sqlarea.area.lpdbOrdCondInfo; - HB_ULONG ulStartRec, ulNextCount = 0; - HB_LONG lStep = 0; - PHB_ITEM pItem, pEvalItem = NULL; + PMIXTAG pTag; + PMIXKEY pKey = NULL; + LPDBORDERCONDINFO pOrdCondInfo = pArea->sqlarea.area.lpdbOrdCondInfo; + HB_ULONG ulStartRec, ulNextCount = 0; + HB_LONG lStep = 0; + PHB_ITEM pItem, pEvalItem = NULL; - pTag = ( PMIXTAG ) hb_xgrab( sizeof( MIXTAG ) ); + pTag = ( PMIXTAG ) hb_xgrab( sizeof( MIXTAG ) ); memset( pTag, 0, sizeof( MIXTAG ) ); - pTag->pArea = pArea; + pTag->pArea = pArea; - pTag->szName = ( char * ) hb_xgrab( MIX_MAXTAGNAMELEN + 1 ); + pTag->szName = ( char * ) hb_xgrab( MIX_MAXTAGNAMELEN + 1 ); hb_strncpyUpperTrim( pTag->szName, szTagName, MIX_MAXTAGNAMELEN ); pTag->szKeyExpr = ( char * ) hb_xgrab( hb_itemGetCLen( pKeyExpr ) + 1 ); hb_strncpyTrim( pTag->szKeyExpr, hb_itemGetCPtr( pKeyExpr ), hb_itemGetCLen( pKeyExpr ) ); /* TODO: FOR expresion */ - pTag->szForExpr = NULL; + pTag->szForExpr = NULL; - pTag->pKeyItem = pKeyItem; - pTag->pForItem = pForItem; - pTag->bType = bType; - pTag->uiKeyLen = uiKeyLen; + pTag->pKeyItem = pKeyItem; + pTag->pForItem = pForItem; + pTag->bType = bType; + pTag->uiKeyLen = uiKeyLen; - pTag->uiTotalLen = sizeof( MIXKEY ) + pTag->uiKeyLen; + pTag->uiTotalLen = sizeof( MIXKEY ) + pTag->uiKeyLen; /* Use national support */ - if ( bType == 'C' ) + if( bType == 'C' ) { if( pArea->sqlarea.area.cdPage && - !HB_CDP_ISBINSORT( pArea->sqlarea.area.cdPage ) ) + ! HB_CDP_ISBINSORT( pArea->sqlarea.area.cdPage ) ) { pTag->pCodepage = pArea->sqlarea.area.cdPage; } } - pTag->Root = hb_mixTagCreateNode( pTag, HB_TRUE ); + pTag->Root = hb_mixTagCreateNode( pTag, HB_TRUE ); - ulStartRec = 0; + ulStartRec = 0; - if ( pOrdCondInfo ) + if( pOrdCondInfo ) { - pEvalItem = pOrdCondInfo->itmCobEval; - lStep = pOrdCondInfo->lStep; + pEvalItem = pOrdCondInfo->itmCobEval; + lStep = pOrdCondInfo->lStep; } - if ( ! pOrdCondInfo || pOrdCondInfo->fAll ) + if( ! pOrdCondInfo || pOrdCondInfo->fAll ) { pArea->pTag = NULL; } else { - if ( pOrdCondInfo->itmRecID ) + if( pOrdCondInfo->itmRecID ) ulStartRec = hb_itemGetNL( pOrdCondInfo->itmRecID ); - if ( ulStartRec ) + if( ulStartRec ) { ulNextCount = 1; } - else if ( pOrdCondInfo->fRest || pOrdCondInfo->lNextCount > 0 ) + else if( pOrdCondInfo->fRest || pOrdCondInfo->lNextCount > 0 ) { - if ( pOrdCondInfo->itmStartRecID ) + if( pOrdCondInfo->itmStartRecID ) ulStartRec = hb_itemGetNL( pOrdCondInfo->itmStartRecID ); - if ( !ulStartRec ) + if( ! ulStartRec ) ulStartRec = pArea->sqlarea.ulRecNo; - if ( pArea->sqlarea.area.lpdbOrdCondInfo->lNextCount > 0 ) + if( pArea->sqlarea.area.lpdbOrdCondInfo->lNextCount > 0 ) ulNextCount = pOrdCondInfo->lNextCount; } - else if ( ! pOrdCondInfo->fUseCurrent ) + else if( ! pOrdCondInfo->fUseCurrent ) { pArea->pTag = NULL; } } - if ( ulStartRec == 0 && pArea->pTag == NULL ) + if( ulStartRec == 0 && pArea->pTag == NULL ) ulStartRec = 1; - if ( ulStartRec ) + if( ulStartRec ) { SELF_GOTO( ( AREAP ) pArea, ulStartRec ); } @@ -884,41 +886,42 @@ static PMIXTAG hb_mixTagCreate( const char* szTagName, PHB_ITEM pKeyExpr, PHB_IT SELF_GOTOP( ( AREAP ) pArea ); } - while ( ! pArea->sqlarea.area.fEof ) + while( ! pArea->sqlarea.area.fEof ) { - if ( pEvalItem ) + if( pEvalItem ) { - if ( lStep >= pOrdCondInfo->lStep ) + if( lStep >= pOrdCondInfo->lStep ) { lStep = 0; - if ( ! hb_mixEvalCond( NULL, pEvalItem ) ) + if( ! hb_mixEvalCond( NULL, pEvalItem ) ) break; } ++lStep; } - if ( pWhileItem && ! hb_mixEvalCond( NULL, pWhileItem ) ) + if( pWhileItem && ! hb_mixEvalCond( NULL, pWhileItem ) ) { break; } - if ( pForItem == NULL || hb_mixEvalCond( NULL, pForItem ) ) + if( pForItem == NULL || hb_mixEvalCond( NULL, pForItem ) ) { pItem = hb_vmEvalBlockOrMacro( pKeyItem ); - pKey = hb_mixKeyPutItem( pKey, pItem, pArea->sqlarea.ulRecNo, pTag ); + pKey = hb_mixKeyPutItem( pKey, pItem, pArea->sqlarea.ulRecNo, pTag ); hb_mixTagAddKey( pTag, pKey ); } - if ( ulNextCount ) + if( ulNextCount ) { ulNextCount--; - if ( !ulNextCount ) break; + if( ! ulNextCount ) + break; } - if ( SELF_SKIPRAW( ( AREAP ) pArea, 1 ) == HB_FAILURE ) + if( SELF_SKIPRAW( ( AREAP ) pArea, 1 ) == HB_FAILURE ) break; } - if ( pKey ) + if( pKey ) hb_mixKeyFree( pKey ); return pTag; @@ -927,12 +930,12 @@ static PMIXTAG hb_mixTagCreate( const char* szTagName, PHB_ITEM pKeyExpr, PHB_IT static void hb_mixTagDestroyNode( PMIXNODE pNode ) { - if ( ! pNode->Leaf ) + if( ! pNode->Leaf ) { - unsigned int ui; + unsigned int ui; - for ( ui = 0; ui <= pNode->KeyCount; ui++ ) - hb_mixTagDestroyNode( pNode->Child[ ui ] ); + for( ui = 0; ui <= pNode->KeyCount; ui++ ) + hb_mixTagDestroyNode( pNode->Child[ ui ] ); } hb_xfree( pNode ); } @@ -940,25 +943,25 @@ static void hb_mixTagDestroyNode( PMIXNODE pNode ) static void hb_mixTagDestroy( PMIXTAG pTag ) { - if ( pTag->szName ) + if( pTag->szName ) hb_xfree( pTag->szName ); - if ( pTag->szKeyExpr ) + if( pTag->szKeyExpr ) hb_xfree( pTag->szKeyExpr ); - if ( pTag->szForExpr ) + if( pTag->szForExpr ) hb_xfree( pTag->szForExpr ); - if ( pTag->pKeyItem ) + if( pTag->pKeyItem ) hb_vmDestroyBlockOrMacro( pTag->pKeyItem ); - if ( pTag->pForItem ) + if( pTag->pForItem ) hb_vmDestroyBlockOrMacro( pTag->pForItem ); - if ( pTag->Root ) + if( pTag->Root ) hb_mixTagDestroyNode( pTag->Root ); - if ( pTag->HotKey ) + if( pTag->HotKey ) hb_mixKeyFree( pTag->HotKey ); hb_xfree( pTag ); @@ -967,84 +970,86 @@ static void hb_mixTagDestroy( PMIXTAG pTag ) static void hb_mixTagGoTop( PMIXTAG pTag ) { - PMIXNODE pNode; + PMIXNODE pNode; pNode = pTag->Root; - while ( ! pNode->Leaf ) + while( ! pNode->Leaf ) { pNode = pNode->Child[ 0 ]; } - if ( ! pNode->KeyCount ) + if( ! pNode->KeyCount ) { pTag->fEof = HB_TRUE; return; } - pTag->fEof = HB_FALSE; - pTag->CurNode = pNode; - pTag->CurPos = 0; - pTag->CurKey = MIX_KEY( pTag, pTag->CurNode, 0 ); + pTag->fEof = HB_FALSE; + pTag->CurNode = pNode; + pTag->CurPos = 0; + pTag->CurKey = MIX_KEY( pTag, pTag->CurNode, 0 ); } static void hb_mixTagGoBottom( PMIXTAG pTag ) { - PMIXNODE pNode; + PMIXNODE pNode; pNode = pTag->Root; - while ( ! pNode->Leaf ) + while( ! pNode->Leaf ) { pNode = pNode->Child[ pNode->KeyCount ]; } - if ( ! pNode->KeyCount ) + if( ! pNode->KeyCount ) { pTag->fEof = HB_TRUE; return; } - pTag->fEof = HB_FALSE; - pTag->CurNode = pNode; - pTag->CurPos = pNode->KeyCount - 1; - pTag->CurKey = MIX_KEY( pTag, pTag->CurNode, pTag->CurPos ); + pTag->fEof = HB_FALSE; + pTag->CurNode = pNode; + pTag->CurPos = pNode->KeyCount - 1; + pTag->CurKey = MIX_KEY( pTag, pTag->CurNode, pTag->CurPos ); } static void hb_mixTagSkip( PMIXTAG pTag, HB_LONG lSkip ) { - PMIXNODE pNode, pNode2; - unsigned int uiPos, uiPos2; + PMIXNODE pNode, pNode2; + unsigned int uiPos, uiPos2; pNode = pTag->CurNode; uiPos = pTag->CurPos; /* printf("hb_mixTagSkip: CurNode=%p, CurPos=%d lSkip=%d\n", pNode, uiPos, lSkip ); */ - if ( lSkip > 0 ) + if( lSkip > 0 ) { pTag->fBof = HB_FALSE; - while ( ! pTag->fEof && lSkip > 0 ) + while( ! pTag->fEof && lSkip > 0 ) { - if ( pNode->Leaf ) + if( pNode->Leaf ) { - if ( ( HB_LONG ) (pNode->KeyCount - 1 - uiPos) >= lSkip ) + if( ( HB_LONG ) ( pNode->KeyCount - 1 - uiPos ) >= lSkip ) { uiPos += lSkip; lSkip = 0; } - else if ( pNode->KeyCount - 1 > uiPos ) + else if( pNode->KeyCount - 1 > uiPos ) { - lSkip -= ( HB_LONG ) (pNode->KeyCount - 1 - uiPos); + lSkip -= ( HB_LONG ) ( pNode->KeyCount - 1 - uiPos ); uiPos = pNode->KeyCount - 1; } - if ( lSkip ) + if( lSkip ) { - do { - if ( pNode->Parent ) + do + { + if( pNode->Parent ) uiPos = hb_mixTagNodeParentIndex( pNode ); pNode = pNode->Parent; - } while ( pNode && uiPos == pNode->KeyCount ); + } + while( pNode && uiPos == pNode->KeyCount ); - if ( pNode ) + if( pNode ) { lSkip--; } @@ -1057,7 +1062,7 @@ static void hb_mixTagSkip( PMIXTAG pTag, HB_LONG lSkip ) else { pNode = pNode->Child[ uiPos + 1 ]; - while ( ! pNode->Leaf ) + while( ! pNode->Leaf ) { pNode = pNode->Child[ 0 ]; } @@ -1066,9 +1071,9 @@ static void hb_mixTagSkip( PMIXTAG pTag, HB_LONG lSkip ) } } } - else if ( lSkip < 0 ) + else if( lSkip < 0 ) { - lSkip = - lSkip; + lSkip = -lSkip; /* This is not needed. skip(-1) from Eof is processed inside sqlmixSkipRaw @@ -1078,43 +1083,45 @@ static void hb_mixTagSkip( PMIXTAG pTag, HB_LONG lSkip ) lSkip--; pTag->fBof = pTag->fEof; } -*/ - pTag->fBof = pTag->fEof; + */ + pTag->fBof = pTag->fEof; - while ( ! pTag->fBof && lSkip > 0 ) + while( ! pTag->fBof && lSkip > 0 ) { - if ( pNode->Leaf ) + if( pNode->Leaf ) { - if ( ( HB_LONG ) uiPos >= lSkip ) + if( ( HB_LONG ) uiPos >= lSkip ) { uiPos -= lSkip; lSkip = 0; } - else if ( uiPos ) + else if( uiPos ) { lSkip -= uiPos; uiPos = 0; } - if ( lSkip ) + if( lSkip ) { - pNode2 = pNode; - uiPos2 = uiPos; - do { - if ( pNode->Parent ) + pNode2 = pNode; + uiPos2 = uiPos; + do + { + if( pNode->Parent ) uiPos = hb_mixTagNodeParentIndex( pNode ); pNode = pNode->Parent; - } while ( pNode && uiPos == 0 ); + } + while( pNode && uiPos == 0 ); - if ( pNode ) + if( pNode ) { uiPos--; lSkip--; } else { - pNode = pNode2; - uiPos = uiPos2; - pTag->fBof = HB_TRUE; + pNode = pNode2; + uiPos = uiPos2; + pTag->fBof = HB_TRUE; } } } @@ -1125,17 +1132,17 @@ static void hb_mixTagSkip( PMIXTAG pTag, HB_LONG lSkip ) pNode = pNode->Child[ uiPos ]; uiPos = pNode->KeyCount; } - while ( ! pNode->Leaf ); + while( ! pNode->Leaf ); uiPos--; lSkip--; } } } - if ( ! pTag->fEof ) + if( ! pTag->fEof ) { - pTag->CurNode = pNode; - pTag->CurPos = uiPos; - pTag->CurKey = MIX_KEY( pTag, pNode, uiPos ); + pTag->CurNode = pNode; + pTag->CurPos = uiPos; + pTag->CurKey = MIX_KEY( pTag, pNode, uiPos ); } } @@ -1144,27 +1151,27 @@ static void hb_mixTagSkip( PMIXTAG pTag, HB_LONG lSkip ) static PMIXTAG hb_mixFindTag( SQLMIXAREAP pArea, PHB_ITEM pOrder ) { - PMIXTAG pTag; + PMIXTAG pTag; - if ( HB_IS_NUMBER( pOrder ) ) + if( HB_IS_NUMBER( pOrder ) ) { - int iOrder, iCurr = 0; + int iOrder, iCurr = 0; - iOrder = hb_itemGetNI( pOrder ); + iOrder = hb_itemGetNI( pOrder ); - pTag = pArea->pTagList; - while ( pTag && iOrder != ++iCurr ) + pTag = pArea->pTagList; + while( pTag && iOrder != ++iCurr ) { pTag = pTag->pNext; } } else { - char szTag[ MIX_MAXTAGNAMELEN + 1 ]; + char szTag[ MIX_MAXTAGNAMELEN + 1 ]; hb_strncpyUpperTrim( szTag, hb_itemGetCPtr( pOrder ), MIX_MAXTAGNAMELEN ); pTag = pArea->pTagList; - while ( pTag && hb_stricmp( szTag, pTag->szName ) ) + while( pTag && hb_stricmp( szTag, pTag->szName ) ) { pTag = pTag->pNext; } @@ -1178,14 +1185,14 @@ static PMIXTAG hb_mixFindTag( SQLMIXAREAP pArea, PHB_ITEM pOrder ) static HB_ULONG hb_mixTagNodeKeyCount( PMIXNODE pNode ) { - HB_ULONG ulKeyCount; - unsigned int ui; + HB_ULONG ulKeyCount; + unsigned int ui; ulKeyCount = pNode->KeyCount; - if ( ! pNode->Leaf ) + if( ! pNode->Leaf ) { - for ( ui = 0; ui <= pNode->KeyCount; ui++ ) - ulKeyCount += hb_mixTagNodeKeyCount( pNode->Child[ ui ] ); + for( ui = 0; ui <= pNode->KeyCount; ui++ ) + ulKeyCount += hb_mixTagNodeKeyCount( pNode->Child[ ui ] ); } return ulKeyCount; } @@ -1195,21 +1202,21 @@ static HB_BOOL hb_mixCheckRecordFilter( SQLMIXAREAP pArea, HB_ULONG ulRecNo ) { HB_BOOL lResult = HB_FALSE; - if ( pArea->sqlarea.area.dbfi.itmCobExpr || hb_setGetDeleted() ) + if( pArea->sqlarea.area.dbfi.itmCobExpr || hb_setGetDeleted() ) { - if ( pArea->sqlarea.ulRecNo != ulRecNo || pArea->sqlarea.lpdbPendingRel ) + if( pArea->sqlarea.ulRecNo != ulRecNo || pArea->sqlarea.lpdbPendingRel ) SELF_GOTO( ( AREAP ) pArea, ulRecNo ); - if ( hb_setGetDeleted() ) + if( hb_setGetDeleted() ) SUPER_DELETED( ( AREAP ) pArea, &lResult ); - if ( !lResult && pArea->sqlarea.area.dbfi.itmCobExpr ) + if( ! lResult && pArea->sqlarea.area.dbfi.itmCobExpr ) { PHB_ITEM pResult = hb_vmEvalBlock( pArea->sqlarea.area.dbfi.itmCobExpr ); - lResult = HB_IS_LOGICAL( pResult ) && !hb_itemGetL( pResult ); + lResult = HB_IS_LOGICAL( pResult ) && ! hb_itemGetL( pResult ); } } - return !lResult; + return ! lResult; } @@ -1217,21 +1224,21 @@ static HB_ULONG hb_mixDBOIKeyCount( PMIXTAG pTag, HB_BOOL fFilter ) { HB_ULONG ulKeyCount; - if ( ! pTag ) + if( ! pTag ) return 0; - if ( fFilter && pTag->pArea->sqlarea.area.dbfi.fFilter ) + if( fFilter && pTag->pArea->sqlarea.area.dbfi.fFilter ) { - PMIXNODE pNode = pTag->CurNode; - unsigned int uiPos = pTag->CurPos; - HB_ULONG ulRecNo = pTag->pArea->sqlarea.ulRecNo; + PMIXNODE pNode = pTag->CurNode; + unsigned int uiPos = pTag->CurPos; + HB_ULONG ulRecNo = pTag->pArea->sqlarea.ulRecNo; ulKeyCount = 0; hb_mixTagGoTop( pTag ); - while ( ! pTag->fEof ) + while( ! pTag->fEof ) { - if ( hb_mixCheckRecordFilter( pTag->pArea, pTag->CurKey->rec ) ) + if( hb_mixCheckRecordFilter( pTag->pArea, pTag->CurKey->rec ) ) ulKeyCount++; hb_mixTagSkip( pTag, 1 ); } @@ -1251,28 +1258,28 @@ static HB_ULONG hb_mixDBOIKeyNo( PMIXTAG pTag, HB_BOOL fFilter ) { HB_ULONG ulKeyCount; - if ( ! pTag ) + if( ! pTag ) return 0; - if ( fFilter ) + if( fFilter ) ulKeyCount = 0; else { - PMIXNODE pNode = pTag->CurNode; - unsigned int ui, uiPos = pTag->CurPos; + PMIXNODE pNode = pTag->CurNode; + unsigned int ui, uiPos = pTag->CurPos; ulKeyCount = 1; - while ( pNode ) + while( pNode ) { ulKeyCount += uiPos; - if ( ! pNode->Leaf ) + if( ! pNode->Leaf ) { - for ( ui = 0; ui < uiPos; ui++ ) + for( ui = 0; ui < uiPos; ui++ ) ulKeyCount += hb_mixTagNodeKeyCount( pNode->Child[ ui ] ); } pNode = pNode->Parent; - if ( pNode ) + if( pNode ) uiPos = hb_mixTagNodeParentIndex( pNode ); } } @@ -1281,31 +1288,31 @@ static HB_ULONG hb_mixDBOIKeyNo( PMIXTAG pTag, HB_BOOL fFilter ) /* -======================================================================= - SQLMIX RDD METHODS -======================================================================= -*/ + ======================================================================= + SQLMIX RDD METHODS + ======================================================================= + */ static HB_ERRCODE sqlmixGoBottom( SQLMIXAREAP pArea ) { HB_ERRCODE retval; - if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) + if( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( ! pArea->pTag ) + if( ! pArea->pTag ) return SUPER_GOBOTTOM( ( AREAP ) pArea ); - if ( pArea->sqlarea.lpdbPendingRel && pArea->sqlarea.lpdbPendingRel->isScoped ) + if( pArea->sqlarea.lpdbPendingRel && pArea->sqlarea.lpdbPendingRel->isScoped ) SELF_FORCEREL( ( AREAP ) pArea ); hb_mixTagGoBottom( pArea->pTag ); - pArea->sqlarea.area.fTop = HB_FALSE; - pArea->sqlarea.area.fBottom = HB_TRUE; + pArea->sqlarea.area.fTop = HB_FALSE; + pArea->sqlarea.area.fBottom = HB_TRUE; - retval = SELF_GOTO( ( AREAP ) pArea, pArea->pTag->CurKey ? pArea->pTag->CurKey->rec : 0 ); - if ( retval != HB_FAILURE && pArea->sqlarea.fPositioned ) + retval = SELF_GOTO( ( AREAP ) pArea, pArea->pTag->CurKey ? pArea->pTag->CurKey->rec : 0 ); + if( retval != HB_FAILURE && pArea->sqlarea.fPositioned ) retval = SELF_SKIPFILTER( ( AREAP ) pArea, -1 ); return retval; @@ -1316,22 +1323,22 @@ static HB_ERRCODE sqlmixGoTop( SQLMIXAREAP pArea ) { HB_ERRCODE retval; - if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) + if( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( ! pArea->pTag ) + if( ! pArea->pTag ) return SUPER_GOTOP( ( AREAP ) pArea ); - if ( pArea->sqlarea.lpdbPendingRel && pArea->sqlarea.lpdbPendingRel->isScoped ) + if( pArea->sqlarea.lpdbPendingRel && pArea->sqlarea.lpdbPendingRel->isScoped ) SELF_FORCEREL( ( AREAP ) pArea ); hb_mixTagGoTop( pArea->pTag ); - pArea->sqlarea.area.fTop = HB_TRUE; - pArea->sqlarea.area.fBottom = HB_FALSE; + pArea->sqlarea.area.fTop = HB_TRUE; + pArea->sqlarea.area.fBottom = HB_FALSE; - retval = SELF_GOTO( ( AREAP ) pArea, pArea->pTag->CurKey ? pArea->pTag->CurKey->rec : 0 ); - if ( retval != HB_FAILURE && pArea->sqlarea.fPositioned ) + retval = SELF_GOTO( ( AREAP ) pArea, pArea->pTag->CurKey ? pArea->pTag->CurKey->rec : 0 ); + if( retval != HB_FAILURE && pArea->sqlarea.fPositioned ) retval = SELF_SKIPFILTER( ( AREAP ) pArea, 1 ); return retval; @@ -1340,52 +1347,52 @@ static HB_ERRCODE sqlmixGoTop( SQLMIXAREAP pArea ) static HB_ERRCODE sqlmixSeek( SQLMIXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pItem, HB_BOOL fFindLast ) { - if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) + if( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( ! pArea->pTag ) + if( ! pArea->pTag ) { sqlmixErrorRT( pArea, EG_NOORDER, 1201, NULL, 0, EF_CANDEFAULT ); return HB_FAILURE; } else { - PMIXKEY pKey; - HB_ERRCODE errCode = HB_SUCCESS; - HB_BOOL fEOF; - PMIXTAG pTag = pArea->pTag; - PMIXNODE pNode; - unsigned int uiKeyLen, ui; + PMIXKEY pKey; + HB_ERRCODE errCode = HB_SUCCESS; + HB_BOOL fEOF; + PMIXTAG pTag = pArea->pTag; + PMIXNODE pNode; + unsigned int uiKeyLen, ui; - if ( pArea->sqlarea.lpdbPendingRel && pArea->sqlarea.lpdbPendingRel->isScoped ) + if( pArea->sqlarea.lpdbPendingRel && pArea->sqlarea.lpdbPendingRel->isScoped ) SELF_FORCEREL( ( AREAP ) pArea ); - pArea->sqlarea.area.fTop = pArea->sqlarea.area.fBottom = HB_FALSE; - pArea->sqlarea.area.fEof = HB_FALSE; + pArea->sqlarea.area.fTop = pArea->sqlarea.area.fBottom = HB_FALSE; + pArea->sqlarea.area.fEof = HB_FALSE; - pKey = hb_mixKeyPutItem( NULL, pItem, fFindLast ? ( HB_ULONG ) -1 : 0, pTag ); + pKey = hb_mixKeyPutItem( NULL, pItem, fFindLast ? ( HB_ULONG ) -1 : 0, pTag ); - uiKeyLen = pTag->uiKeyLen; - if ( pTag->bType == 'C' ) + uiKeyLen = pTag->uiKeyLen; + if( pTag->bType == 'C' ) { uiKeyLen = ( unsigned int ) hb_itemGetCLen( pItem ); - if ( uiKeyLen > pTag->uiKeyLen ) + if( uiKeyLen > pTag->uiKeyLen ) uiKeyLen = pTag->uiKeyLen; } hb_mixTagFindKey( pTag, pKey, uiKeyLen, &pNode, &ui, HB_TRUE ); hb_mixTagSetCurrent( pTag, pNode, ui ); - if ( fFindLast ) + if( fFindLast ) { - if ( pTag->fEof ) + if( pTag->fEof ) hb_mixTagGoBottom( pTag ); else hb_mixTagSkip( pTag, -1 ); pArea->sqlarea.area.fFound = ! pTag->fEof && ( uiKeyLen == 0 || memcmp( pTag->CurKey->val, pKey->val, ( HB_ULONG ) uiKeyLen ) == 0 ); - if ( ! pArea->sqlarea.area.fFound ) + if( ! pArea->sqlarea.area.fFound ) hb_mixTagSetCurrent( pTag, pNode, ui ); } else @@ -1395,21 +1402,21 @@ static HB_ERRCODE sqlmixSeek( SQLMIXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pIt fEOF = pTag->fEof; - if ( !fEOF ) + if( ! fEOF ) { errCode = SELF_GOTO( ( AREAP ) pArea, pTag->CurKey->rec ); - if ( errCode != HB_FAILURE && pArea->sqlarea.fPositioned ) + if( errCode != HB_FAILURE && pArea->sqlarea.fPositioned ) { errCode = SELF_SKIPFILTER( ( AREAP ) pArea, fFindLast ? -1 : 1 ); - if ( errCode != HB_FAILURE && pArea->sqlarea.fPositioned ) + if( errCode != HB_FAILURE && pArea->sqlarea.fPositioned ) { pArea->sqlarea.area.fFound = ( uiKeyLen == 0 || memcmp( pTag->CurKey->val, pKey->val, ( HB_ULONG ) uiKeyLen ) == 0 ); - if ( ! pArea->sqlarea.area.fFound && ! fSoftSeek ) + if( ! pArea->sqlarea.area.fFound && ! fSoftSeek ) fEOF = HB_TRUE; } } } - if ( errCode != HB_FAILURE && fEOF ) + if( errCode != HB_FAILURE && fEOF ) { errCode = SELF_GOTO( ( AREAP ) pArea, 0 ); } @@ -1423,21 +1430,21 @@ static HB_ERRCODE sqlmixSeek( SQLMIXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pIt static HB_ERRCODE sqlmixSkipRaw( SQLMIXAREAP pArea, HB_LONG lToSkip ) { - PMIXTAG pTag = pArea->pTag; - HB_BOOL fOut = HB_FALSE; + PMIXTAG pTag = pArea->pTag; + HB_BOOL fOut = HB_FALSE; - if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) + if( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( ! pTag || lToSkip == 0 ) + if( ! pTag || lToSkip == 0 ) return SUPER_SKIPRAW( ( AREAP ) pArea, lToSkip ); - if ( pArea->sqlarea.lpdbPendingRel ) + if( pArea->sqlarea.lpdbPendingRel ) SELF_FORCEREL( ( AREAP ) pArea ); - if ( ! hb_mixTagRefreshKey( pTag ) ) + if( ! hb_mixTagRefreshKey( pTag ) ) { - if ( lToSkip > 0 || pArea->sqlarea.fPositioned ) + if( lToSkip > 0 || pArea->sqlarea.fPositioned ) fOut = HB_TRUE; else { @@ -1447,55 +1454,55 @@ static HB_ERRCODE sqlmixSkipRaw( SQLMIXAREAP pArea, HB_LONG lToSkip ) } } - if ( ! fOut ) + if( ! fOut ) hb_mixTagSkip( pTag, lToSkip ); - if ( SELF_GOTO( ( AREAP ) pArea, ( pTag->fEof || fOut ) ? 0 : pTag->CurKey->rec ) != HB_SUCCESS ) + if( SELF_GOTO( ( AREAP ) pArea, ( pTag->fEof || fOut ) ? 0 : pTag->CurKey->rec ) != HB_SUCCESS ) return HB_FAILURE; - pArea->sqlarea.area.fEof = pTag->fEof; - pArea->sqlarea.area.fBof = pTag->fBof; + pArea->sqlarea.area.fEof = pTag->fEof; + pArea->sqlarea.area.fBof = pTag->fBof; return HB_SUCCESS; } static HB_ERRCODE sqlmixGoCold( SQLMIXAREAP pArea ) { - HB_BOOL fRecordChanged = pArea->sqlarea.fRecordChanged; - HB_BOOL fAppend = pArea->sqlarea.fAppend; + HB_BOOL fRecordChanged = pArea->sqlarea.fRecordChanged; + HB_BOOL fAppend = pArea->sqlarea.fAppend; - if ( SUPER_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) + if( SUPER_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( fRecordChanged && pArea->pTagList ) + if( fRecordChanged && pArea->pTagList ) { - PMIXTAG pTag; - HB_BOOL fAdd, fDel; - LPDBRELINFO lpdbPendingRel; + PMIXTAG pTag; + HB_BOOL fAdd, fDel; + LPDBRELINFO lpdbPendingRel; - lpdbPendingRel = pArea->sqlarea.lpdbPendingRel; + lpdbPendingRel = pArea->sqlarea.lpdbPendingRel; pArea->sqlarea.lpdbPendingRel = NULL; - pTag = pArea->pTagList; - while ( pTag ) + pTag = pArea->pTagList; + while( pTag ) { - if ( ! pTag->fCustom ) + if( ! pTag->fCustom ) { PMIXKEY pKey = hb_mixKeyEval( NULL, pTag ); - if ( pTag->pForItem != NULL ) + if( pTag->pForItem != NULL ) fAdd = hb_mixEvalCond( pArea, pTag->pForItem ); else fAdd = HB_TRUE; - if ( fAppend ) + if( fAppend ) fDel = HB_FALSE; else { - if ( hb_mixKeyCompare( pTag, pKey, pTag->HotKey, pTag->uiKeyLen ) == 0 ) + if( hb_mixKeyCompare( pTag, pKey, pTag->HotKey, pTag->uiKeyLen ) == 0 ) { - fDel = !fAdd && pTag->HotFor; - fAdd = fAdd && !pTag->HotFor; + fDel = ! fAdd && pTag->HotFor; + fAdd = fAdd && ! pTag->HotFor; } else { @@ -1503,10 +1510,10 @@ static HB_ERRCODE sqlmixGoCold( SQLMIXAREAP pArea ) } } - if ( fDel ) + if( fDel ) hb_mixTagDelKey( pTag, pTag->HotKey ); - if ( fAdd ) + if( fAdd ) hb_mixTagAddKey( pTag, pKey ); hb_mixKeyFree( pKey ); @@ -1527,18 +1534,18 @@ static HB_ERRCODE sqlmixGoHot( SQLMIXAREAP pArea ) /* if ( pArea->fRecordChanged ) printf( "sqlmixGoHot: multiple marking buffer as hot." ); -*/ + */ - if ( SUPER_GOHOT( ( AREAP ) pArea ) == HB_FAILURE ) + if( SUPER_GOHOT( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; pTag = pArea->pTagList; - while ( pTag ) + while( pTag ) { - if ( !pTag->fCustom ) + if( ! pTag->fCustom ) { - pTag->HotKey = hb_mixKeyEval( pTag->HotKey, pTag ); - pTag->HotFor = pTag->pForItem == NULL || hb_mixEvalCond( pArea, pTag->pForItem ); + pTag->HotKey = hb_mixKeyEval( pTag->HotKey, pTag ); + pTag->HotFor = pTag->pForItem == NULL || hb_mixEvalCond( pArea, pTag->pForItem ); } pTag = pTag->pNext; } @@ -1548,36 +1555,36 @@ static HB_ERRCODE sqlmixGoHot( SQLMIXAREAP pArea ) static HB_ERRCODE sqlmixClose( SQLMIXAREAP pArea ) { - if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) + if( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( SUPER_CLOSE( ( AREAP ) pArea ) == HB_FAILURE ) + if( SUPER_CLOSE( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( SELF_ORDLSTCLEAR( ( AREAP ) pArea ) == HB_FAILURE ) + if( SELF_ORDLSTCLEAR( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; return HB_SUCCESS; } -static HB_ERRCODE sqlmixStructSize( SQLMIXAREAP pArea, HB_USHORT* StructSize ) +static HB_ERRCODE sqlmixStructSize( SQLMIXAREAP pArea, HB_USHORT * StructSize ) { HB_SYMBOL_UNUSED( pArea ); - * StructSize = sizeof( SQLMIXAREA ); + *StructSize = sizeof( SQLMIXAREA ); return HB_SUCCESS; } static HB_ERRCODE sqlmixOrderListClear( SQLMIXAREAP pArea ) { - PMIXTAG pTag; + PMIXTAG pTag; - while ( pArea->pTagList ) + while( pArea->pTagList ) { - pTag = pArea->pTagList; - pArea->pTagList = pTag->pNext; + pTag = pArea->pTagList; + pArea->pTagList = pTag->pNext; hb_mixTagDestroy( pTag ); } pArea->pTag = NULL; @@ -1587,12 +1594,12 @@ static HB_ERRCODE sqlmixOrderListClear( SQLMIXAREAP pArea ) static HB_ERRCODE sqlmixOrderListFocus( SQLMIXAREAP pArea, LPDBORDERINFO pOrderInfo ) { - if ( pArea->pTag ) + if( pArea->pTag ) { pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, pArea->pTag->szName ); } - if ( pOrderInfo->itmOrder ) + if( pOrderInfo->itmOrder ) { pArea->pTag = hb_mixFindTag( pArea, pOrderInfo->itmOrder ); } @@ -1602,45 +1609,46 @@ static HB_ERRCODE sqlmixOrderListFocus( SQLMIXAREAP pArea, LPDBORDERINFO pOrderI static HB_ERRCODE sqlmixOrderCreate( SQLMIXAREAP pArea, LPDBORDERCREATEINFO pOrderInfo ) { - PMIXTAG pTagNew, pTag; - PHB_ITEM pKeyItem, pForItem = NULL, pWhileItem = NULL, pResult; - HB_ULONG ulRecNo; - HB_USHORT uiLen; - HB_BYTE bType; + PMIXTAG pTagNew, pTag; + PHB_ITEM pKeyItem, pForItem = NULL, pWhileItem = NULL, pResult; + HB_ULONG ulRecNo; + HB_USHORT uiLen; + HB_BYTE bType; /* Obtain key codeblock */ - if ( pOrderInfo->itmCobExpr ) + if( pOrderInfo->itmCobExpr ) { pKeyItem = hb_itemNew( pOrderInfo->itmCobExpr ); } else { - if ( SELF_COMPILE( ( AREAP ) pArea, hb_itemGetCPtr( pOrderInfo->abExpr ) ) == HB_FAILURE ) + if( SELF_COMPILE( ( AREAP ) pArea, hb_itemGetCPtr( pOrderInfo->abExpr ) ) == HB_FAILURE ) return HB_FAILURE; - pKeyItem = pArea->sqlarea.area.valResult; + pKeyItem = pArea->sqlarea.area.valResult; pArea->sqlarea.area.valResult = NULL; } /* Test key codeblock on EOF */ ulRecNo = pArea->sqlarea.ulRecNo; SELF_GOTO( ( AREAP ) pArea, 0 ); - if ( SELF_EVALBLOCK( ( AREAP ) pArea, pKeyItem ) == HB_FAILURE ) + if( SELF_EVALBLOCK( ( AREAP ) pArea, pKeyItem ) == HB_FAILURE ) { hb_vmDestroyBlockOrMacro( pKeyItem ); SELF_GOTO( ( AREAP ) pArea, ulRecNo ); return HB_FAILURE; } - pResult = pArea->sqlarea.area.valResult; + pResult = pArea->sqlarea.area.valResult; pArea->sqlarea.area.valResult = NULL; - switch ( hb_itemType( pResult ) ) + switch( hb_itemType( pResult ) ) { case HB_IT_STRING: case HB_IT_STRING | HB_IT_MEMO: bType = 'C'; uiLen = ( HB_USHORT ) hb_itemGetCLen( pResult ); - if ( uiLen > MIX_MAXKEYLEN ) uiLen = MIX_MAXKEYLEN; + if( uiLen > MIX_MAXKEYLEN ) + uiLen = MIX_MAXKEYLEN; break; case HB_IT_INTEGER: @@ -1666,7 +1674,7 @@ static HB_ERRCODE sqlmixOrderCreate( SQLMIXAREAP pArea, LPDBORDERCREATEINFO pOrd } hb_itemRelease( pResult ); - if ( bType == 'U' || uiLen == 0 ) + if( bType == 'U' || uiLen == 0 ) { hb_vmDestroyBlockOrMacro( pKeyItem ); SELF_GOTO( ( AREAP ) pArea, ulRecNo ); @@ -1674,64 +1682,64 @@ static HB_ERRCODE sqlmixOrderCreate( SQLMIXAREAP pArea, LPDBORDERCREATEINFO pOrd return HB_FAILURE; } - if ( pArea->sqlarea.area.lpdbOrdCondInfo ) + if( pArea->sqlarea.area.lpdbOrdCondInfo ) { /* Obtain FOR codeblock */ - if ( pArea->sqlarea.area.lpdbOrdCondInfo->itmCobFor ) + if( pArea->sqlarea.area.lpdbOrdCondInfo->itmCobFor ) { pForItem = hb_itemNew( pArea->sqlarea.area.lpdbOrdCondInfo->itmCobFor ); } - else if ( pArea->sqlarea.area.lpdbOrdCondInfo->abFor ) + else if( pArea->sqlarea.area.lpdbOrdCondInfo->abFor ) { - if ( SELF_COMPILE( ( AREAP ) pArea, pArea->sqlarea.area.lpdbOrdCondInfo->abFor ) == HB_FAILURE ) + if( SELF_COMPILE( ( AREAP ) pArea, pArea->sqlarea.area.lpdbOrdCondInfo->abFor ) == HB_FAILURE ) { hb_vmDestroyBlockOrMacro( pKeyItem ); SELF_GOTO( ( AREAP ) pArea, ulRecNo ); return HB_FAILURE; } - pForItem = pArea->sqlarea.area.valResult; + pForItem = pArea->sqlarea.area.valResult; pArea->sqlarea.area.valResult = NULL; } /* Obtain WHILE codeblock */ - if ( pArea->sqlarea.area.lpdbOrdCondInfo->itmCobWhile ) + if( pArea->sqlarea.area.lpdbOrdCondInfo->itmCobWhile ) { pWhileItem = hb_itemNew( pArea->sqlarea.area.lpdbOrdCondInfo->itmCobWhile ); } - else if ( pArea->sqlarea.area.lpdbOrdCondInfo->abWhile ) + else if( pArea->sqlarea.area.lpdbOrdCondInfo->abWhile ) { - if ( SELF_COMPILE( ( AREAP ) pArea, pArea->sqlarea.area.lpdbOrdCondInfo->abWhile ) == HB_FAILURE ) + if( SELF_COMPILE( ( AREAP ) pArea, pArea->sqlarea.area.lpdbOrdCondInfo->abWhile ) == HB_FAILURE ) { hb_vmDestroyBlockOrMacro( pKeyItem ); - if ( pForItem ) + if( pForItem ) hb_vmDestroyBlockOrMacro( pForItem ); SELF_GOTO( ( AREAP ) pArea, ulRecNo ); return HB_FAILURE; } - pWhileItem = pArea->sqlarea.area.valResult; + pWhileItem = pArea->sqlarea.area.valResult; pArea->sqlarea.area.valResult = NULL; } } /* Test FOR codeblock on EOF */ - if ( pForItem ) + if( pForItem ) { - if ( SELF_EVALBLOCK( ( AREAP ) pArea, pForItem ) == HB_FAILURE ) + if( SELF_EVALBLOCK( ( AREAP ) pArea, pForItem ) == HB_FAILURE ) { hb_vmDestroyBlockOrMacro( pKeyItem ); hb_vmDestroyBlockOrMacro( pForItem ); - if ( pWhileItem ) + if( pWhileItem ) hb_vmDestroyBlockOrMacro( pWhileItem ); SELF_GOTO( ( AREAP ) pArea, ulRecNo ); return HB_FAILURE; } - if ( hb_itemType( pArea->sqlarea.area.valResult ) != HB_IT_LOGICAL ) + if( hb_itemType( pArea->sqlarea.area.valResult ) != HB_IT_LOGICAL ) { hb_itemRelease( pArea->sqlarea.area.valResult ); pArea->sqlarea.area.valResult = 0; hb_vmDestroyBlockOrMacro( pKeyItem ); hb_vmDestroyBlockOrMacro( pForItem ); - if ( pWhileItem ) + if( pWhileItem ) hb_vmDestroyBlockOrMacro( pWhileItem ); SELF_GOTO( ( AREAP ) pArea, ulRecNo ); sqlmixErrorRT( pArea, EG_DATATYPE, EDBF_INVALIDFOR, NULL, 0, 0 ); @@ -1747,14 +1755,14 @@ static HB_ERRCODE sqlmixOrderCreate( SQLMIXAREAP pArea, LPDBORDERCREATEINFO pOrd pTagNew = hb_mixTagCreate( pOrderInfo->atomBagName, pOrderInfo->abExpr, pKeyItem, pForItem, pWhileItem, bType, uiLen, pArea ); - if ( pWhileItem ) + if( pWhileItem ) hb_vmDestroyBlockOrMacro( pWhileItem ); /* Append the tag to the end of list */ - if ( pArea->pTagList ) + if( pArea->pTagList ) { pTag = pArea->pTagList; - while ( pTag->pNext ) + while( pTag->pNext ) { pTag = pTag->pNext; } @@ -1772,31 +1780,31 @@ static HB_ERRCODE sqlmixOrderCreate( SQLMIXAREAP pArea, LPDBORDERCREATEINFO pOrd static HB_ERRCODE sqlmixOrderInfo( SQLMIXAREAP pArea, HB_USHORT uiIndex, LPDBORDERINFO pOrderInfo ) { - PMIXTAG pTag; - HB_USHORT uiTag = 0; + PMIXTAG pTag; + HB_USHORT uiTag = 0; switch( uiIndex ) { case DBOI_EVALSTEP: pOrderInfo->itmResult = hb_itemPutNL( pOrderInfo->itmResult, - pArea->sqlarea.area.lpdbOrdCondInfo ? pArea->sqlarea.area.lpdbOrdCondInfo->lStep : 0 ); + pArea->sqlarea.area.lpdbOrdCondInfo ? pArea->sqlarea.area.lpdbOrdCondInfo->lStep : 0 ); return HB_SUCCESS; case DBOI_ORDERCOUNT: pTag = pArea->pTagList; - while ( pTag ) + while( pTag ) { - pTag = pTag->pNext; - uiTag++; + pTag = pTag->pNext; + uiTag++; } pOrderInfo->itmResult = hb_itemPutNI( pOrderInfo->itmResult, uiTag ); return HB_SUCCESS; } - if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) + if( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE ) return HB_FAILURE; - if ( pOrderInfo->itmOrder ) + if( pOrderInfo->itmOrder ) pTag = hb_mixFindTag( pArea, pOrderInfo->itmOrder ); else pTag = pArea->pTag; @@ -1805,39 +1813,39 @@ static HB_ERRCODE sqlmixOrderInfo( SQLMIXAREAP pArea, HB_USHORT uiIndex, LPDBORD { case DBOI_CONDITION: pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, ( pTag ? pTag->szForExpr : NULL ) ); - if ( pTag && pOrderInfo->itmNewVal && HB_IS_STRING( pOrderInfo->itmNewVal ) ) + if( pTag && pOrderInfo->itmNewVal && HB_IS_STRING( pOrderInfo->itmNewVal ) ) { - if ( pTag->szForExpr != NULL ) + if( pTag->szForExpr != NULL ) { hb_xfree( pTag->szForExpr ); pTag->szForExpr = NULL; } - if ( pTag->pForItem != NULL ) + if( pTag->pForItem != NULL ) { hb_vmDestroyBlockOrMacro( pTag->pForItem ); pTag->pForItem = NULL; } - if ( hb_itemGetCLen( pOrderInfo->itmNewVal ) > 0 ) + if( hb_itemGetCLen( pOrderInfo->itmNewVal ) > 0 ) { - const char* pForExpr = hb_itemGetCPtr( pOrderInfo->itmNewVal ); + const char * pForExpr = hb_itemGetCPtr( pOrderInfo->itmNewVal ); - if ( SELF_COMPILE( ( AREAP ) pArea, pForExpr ) == HB_SUCCESS ) + if( SELF_COMPILE( ( AREAP ) pArea, pForExpr ) == HB_SUCCESS ) { - PHB_ITEM pForItem = pArea->sqlarea.area.valResult; + PHB_ITEM pForItem = pArea->sqlarea.area.valResult; pArea->sqlarea.area.valResult = NULL; - if ( SELF_EVALBLOCK( ( AREAP ) pArea, pForItem ) == HB_SUCCESS ) + if( SELF_EVALBLOCK( ( AREAP ) pArea, pForItem ) == HB_SUCCESS ) { - if ( hb_itemType( pArea->sqlarea.area.valResult ) == HB_IT_LOGICAL ) + if( hb_itemType( pArea->sqlarea.area.valResult ) == HB_IT_LOGICAL ) { - pTag->szForExpr = hb_strdup( pForExpr ); - pTag->pForItem = pForItem; - pForItem = NULL; + pTag->szForExpr = hb_strdup( pForExpr ); + pTag->pForItem = pForItem; + pForItem = NULL; } hb_itemRelease( pArea->sqlarea.area.valResult ); pArea->sqlarea.area.valResult = NULL; } - if ( pForItem ) + if( pForItem ) hb_vmDestroyBlockOrMacro( pForItem ); } } @@ -1850,24 +1858,24 @@ static HB_ERRCODE sqlmixOrderInfo( SQLMIXAREAP pArea, HB_USHORT uiIndex, LPDBORD case DBOI_POSITION: case DBOI_KEYNORAW: - if ( pOrderInfo->itmNewVal && HB_IS_NUMERIC( pOrderInfo->itmNewVal ) ) + if( pOrderInfo->itmNewVal && HB_IS_NUMERIC( pOrderInfo->itmNewVal ) ) { /* TODO: pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, hb_cdxDBOIKeyGoto( pArea, pTag, hb_itemGetNL( pOrderInfo->itmNewVal ), uiIndex == DBOI_POSITION ) == HB_SUCCESS ); -*/ + */ } else pOrderInfo->itmResult = hb_itemPutNL( pOrderInfo->itmResult, - hb_mixDBOIKeyNo( pTag, uiIndex == DBOI_POSITION ) ); + hb_mixDBOIKeyNo( pTag, uiIndex == DBOI_POSITION ) ); break; case DBOI_KEYCOUNT: case DBOI_KEYCOUNTRAW: pOrderInfo->itmResult = hb_itemPutNL( pOrderInfo->itmResult, - hb_mixDBOIKeyCount( pTag, uiIndex == DBOI_KEYCOUNT ) ); + hb_mixDBOIKeyCount( pTag, uiIndex == DBOI_KEYCOUNT ) ); break; /* TODO: @@ -1882,7 +1890,7 @@ static HB_ERRCODE sqlmixOrderInfo( SQLMIXAREAP pArea, HB_USHORT uiIndex, LPDBORD hb_cdxDBOIFindRec( pArea, pTag, hb_itemGetNL( pOrderInfo->itmNewVal ), HB_TRUE ) ); break; -*/ + */ case DBOI_NAME: pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, pTag ? pTag->szName : NULL ); break; @@ -1902,18 +1910,18 @@ static HB_ERRCODE sqlmixOrderInfo( SQLMIXAREAP pArea, HB_USHORT uiIndex, LPDBORD case DBOI_SCOPETOP: case DBOI_SCOPEBOTTOM: - if ( pOrderInfo->itmResult ) + if( pOrderInfo->itmResult ) hb_itemClear( pOrderInfo->itmResult ); break; case DBOI_KEYTYPE: - if ( pTag ) + if( pTag ) { - char szType[ 2 ]; + char szType[ 2 ]; - szType[ 0 ] = ( char ) pTag->bType; - szType[ 1 ] = 0; - pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, szType ); + szType[ 0 ] = ( char ) pTag->bType; + szType[ 1 ] = 0; + pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, szType ); } else pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, NULL ); @@ -2033,7 +2041,7 @@ static HB_ERRCODE sqlmixOrderInfo( SQLMIXAREAP pArea, HB_USHORT uiIndex, LPDBORD } break; -*/ + */ case DBOI_SHARED: case DBOI_ISREADONLY: pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, HB_FALSE ); @@ -2064,130 +2072,133 @@ static HB_ERRCODE sqlmixExit( LPRDDNODE pRDD ) static RDDFUNCS sqlmixTable = - {( DBENTRYP_BP ) NULL, /* sqlmixBof */ - ( DBENTRYP_BP ) NULL, /* sqlmixEof */ - ( DBENTRYP_BP ) NULL, /* sqlmixFound */ - ( DBENTRYP_V ) sqlmixGoBottom, - ( DBENTRYP_UL ) NULL, /* sqlmixGoTo */ - ( DBENTRYP_I ) NULL, /* sqlmixGoToId */ - ( DBENTRYP_V ) sqlmixGoTop, - ( DBENTRYP_BIB ) sqlmixSeek, - ( DBENTRYP_L ) NULL, /* sqlmixSkip */ - ( DBENTRYP_L ) NULL, /* sqlmixSkipFilter */ - ( DBENTRYP_L ) sqlmixSkipRaw, - ( DBENTRYP_VF ) NULL, /* sqlmixAddField */ - ( DBENTRYP_B ) NULL, /* sqlmixAppend */ - ( DBENTRYP_I ) NULL, /* sqlmixCreateFields */ - ( DBENTRYP_V ) NULL, /* sqlmixDeleteRec */ - ( DBENTRYP_BP ) NULL, /* sqlmixDeleted */ - ( DBENTRYP_SP ) NULL, /* sqlmixFieldCount */ - ( DBENTRYP_VF ) NULL, /* sqlmixFieldDisplay */ - ( DBENTRYP_SSI ) NULL, /* sqlmixFieldInfo */ - ( DBENTRYP_SCP ) NULL, /* sqlmixFieldName */ - ( DBENTRYP_V ) NULL, /* sqlmixFlush */ - ( DBENTRYP_PP ) NULL, /* sqlmixGetRec */ - ( DBENTRYP_SI ) NULL, /* sqlmixGetValue */ - ( DBENTRYP_SVL ) NULL, /* sqlmixGetVarLen */ - ( DBENTRYP_V ) sqlmixGoCold, - ( DBENTRYP_V ) sqlmixGoHot, - ( DBENTRYP_P ) NULL, /* sqlmixPutRec */ - ( DBENTRYP_SI ) NULL, /* sqlmixPutValue */ - ( DBENTRYP_V ) NULL, /* sqlmixRecall */ - ( DBENTRYP_ULP ) NULL, /* sqlmixRecCount */ - ( DBENTRYP_ISI ) NULL, /* sqlmixRecInfo */ - ( DBENTRYP_ULP ) NULL, /* sqlmixRecNo */ - ( DBENTRYP_I ) NULL, /* sqlmixRecId */ - ( DBENTRYP_S ) NULL, /* sqlmixSetFieldExtent */ - ( DBENTRYP_CP ) NULL, /* sqlmixAlias */ - ( DBENTRYP_V ) sqlmixClose, - ( DBENTRYP_VO ) NULL, /* sqlmixCreate */ - ( DBENTRYP_SI ) NULL, /* sqlmixInfo */ - ( DBENTRYP_V ) NULL, /* sqlmixNewArea */ - ( DBENTRYP_VO ) NULL, /* sqlmixOpen */ - ( DBENTRYP_V ) NULL, /* sqlmixRelease */ - ( DBENTRYP_SP ) sqlmixStructSize, - ( DBENTRYP_CP ) NULL, /* sqlmixSysName */ - ( DBENTRYP_VEI ) NULL, /* sqlmixEval */ - ( DBENTRYP_V ) NULL, /* sqlmixPack */ - ( DBENTRYP_LSP ) NULL, /* sqlmixPackRec */ - ( DBENTRYP_VS ) NULL, /* sqlmixSort */ - ( DBENTRYP_VT ) NULL, /* sqlmixTrans */ - ( DBENTRYP_VT ) NULL, /* sqlmixTransRec */ - ( DBENTRYP_V ) NULL, /* sqlmixZap */ - ( DBENTRYP_VR ) NULL, /* sqlmixChildEnd */ - ( DBENTRYP_VR ) NULL, /* sqlmixChildStart */ - ( DBENTRYP_VR ) NULL, /* sqlmixChildSync */ - ( DBENTRYP_V ) NULL, /* sqlmixSyncChildren */ - ( DBENTRYP_V ) NULL, /* sqlmixClearRel */ - ( DBENTRYP_V ) NULL, /* sqlmixForceRel */ - ( DBENTRYP_SSP ) NULL, /* sqlmixRelArea */ - ( DBENTRYP_VR ) NULL, /* sqlmixRelEval */ - ( DBENTRYP_SI ) NULL, /* sqlmixRelText */ - ( DBENTRYP_VR ) NULL, /* sqlmixSetRel */ - ( DBENTRYP_VOI ) NULL, /* sqlmixOrderListAdd */ - ( DBENTRYP_V ) sqlmixOrderListClear, - ( DBENTRYP_VOI ) NULL, /* sqlmixOrderListDelete */ - ( DBENTRYP_VOI ) sqlmixOrderListFocus, - ( DBENTRYP_V ) NULL, /* sqlmixOrderListRebuild */ - ( DBENTRYP_VOO ) NULL, /* sqlmixOrderCondition */ - ( DBENTRYP_VOC ) sqlmixOrderCreate, - ( DBENTRYP_VOI ) NULL, /* sqlmixOrderDestroy */ - ( DBENTRYP_SVOI ) sqlmixOrderInfo, - ( DBENTRYP_V ) NULL, /* sqlmixClearFilter */ - ( DBENTRYP_V ) NULL, /* sqlmixClearLocate */ - ( DBENTRYP_V ) NULL, /* sqlmixClearScope */ - ( DBENTRYP_VPLP ) NULL, /* sqlmixCountScope */ - ( DBENTRYP_I ) NULL, /* sqlmixFilterText */ - ( DBENTRYP_SI ) NULL, /* sqlmixScopeInfo */ - ( DBENTRYP_VFI ) NULL, /* sqlmixSetFilter */ - ( DBENTRYP_VLO ) NULL, /* sqlmixSetLocate */ - ( DBENTRYP_VOS ) NULL, /* sqlmixSetScope */ - ( DBENTRYP_VPL ) NULL, /* sqlmixSkipScope */ - ( DBENTRYP_B ) NULL, /* sqlmixLocate */ - ( DBENTRYP_CC ) NULL, /* sqlmixCompile */ - ( DBENTRYP_I ) NULL, /* sqlmixError */ - ( DBENTRYP_I ) NULL, /* sqlmixEvalBlock */ - ( DBENTRYP_VSP ) NULL, /* sqlmixRawLock */ - ( DBENTRYP_VL ) NULL, /* sqlmixLock */ - ( DBENTRYP_I ) NULL, /* sqlmixUnLock */ - ( DBENTRYP_V ) NULL, /* sqlmixCloseMemFile */ - ( DBENTRYP_VO ) NULL, /* sqlmixCreateMemFile */ - ( DBENTRYP_SCCS ) NULL, /* sqlmixGetValueFile */ - ( DBENTRYP_VO ) NULL, /* sqlmixOpenMemFile */ - ( DBENTRYP_SCCS ) NULL, /* sqlmixPutValueFile */ - ( DBENTRYP_V ) NULL, /* sqlmixReadDBHeader */ - ( DBENTRYP_V ) NULL, /* sqlmixWriteDBHeader */ - ( DBENTRYP_R ) sqlmixInit, - ( DBENTRYP_R ) sqlmixExit, - ( DBENTRYP_RVVL) NULL, /* sqlmixDrop */ - ( DBENTRYP_RVVL) NULL, /* sqlmixExists */ - ( DBENTRYP_RVVVL) NULL, /* sqlmixRename */ - ( DBENTRYP_RSLV ) NULL, /* sqlmixRddInfo */ - ( DBENTRYP_SVP ) NULL, /* sqlmixWhoCares */ - }; +{ ( DBENTRYP_BP ) NULL, /* sqlmixBof */ + ( DBENTRYP_BP ) NULL, /* sqlmixEof */ + ( DBENTRYP_BP ) NULL, /* sqlmixFound */ + ( DBENTRYP_V ) sqlmixGoBottom, + ( DBENTRYP_UL ) NULL, /* sqlmixGoTo */ + ( DBENTRYP_I ) NULL, /* sqlmixGoToId */ + ( DBENTRYP_V ) sqlmixGoTop, + ( DBENTRYP_BIB ) sqlmixSeek, + ( DBENTRYP_L ) NULL, /* sqlmixSkip */ + ( DBENTRYP_L ) NULL, /* sqlmixSkipFilter */ + ( DBENTRYP_L ) sqlmixSkipRaw, + ( DBENTRYP_VF ) NULL, /* sqlmixAddField */ + ( DBENTRYP_B ) NULL, /* sqlmixAppend */ + ( DBENTRYP_I ) NULL, /* sqlmixCreateFields */ + ( DBENTRYP_V ) NULL, /* sqlmixDeleteRec */ + ( DBENTRYP_BP ) NULL, /* sqlmixDeleted */ + ( DBENTRYP_SP ) NULL, /* sqlmixFieldCount */ + ( DBENTRYP_VF ) NULL, /* sqlmixFieldDisplay */ + ( DBENTRYP_SSI ) NULL, /* sqlmixFieldInfo */ + ( DBENTRYP_SCP ) NULL, /* sqlmixFieldName */ + ( DBENTRYP_V ) NULL, /* sqlmixFlush */ + ( DBENTRYP_PP ) NULL, /* sqlmixGetRec */ + ( DBENTRYP_SI ) NULL, /* sqlmixGetValue */ + ( DBENTRYP_SVL ) NULL, /* sqlmixGetVarLen */ + ( DBENTRYP_V ) sqlmixGoCold, + ( DBENTRYP_V ) sqlmixGoHot, + ( DBENTRYP_P ) NULL, /* sqlmixPutRec */ + ( DBENTRYP_SI ) NULL, /* sqlmixPutValue */ + ( DBENTRYP_V ) NULL, /* sqlmixRecall */ + ( DBENTRYP_ULP ) NULL, /* sqlmixRecCount */ + ( DBENTRYP_ISI ) NULL, /* sqlmixRecInfo */ + ( DBENTRYP_ULP ) NULL, /* sqlmixRecNo */ + ( DBENTRYP_I ) NULL, /* sqlmixRecId */ + ( DBENTRYP_S ) NULL, /* sqlmixSetFieldExtent */ + ( DBENTRYP_CP ) NULL, /* sqlmixAlias */ + ( DBENTRYP_V ) sqlmixClose, + ( DBENTRYP_VO ) NULL, /* sqlmixCreate */ + ( DBENTRYP_SI ) NULL, /* sqlmixInfo */ + ( DBENTRYP_V ) NULL, /* sqlmixNewArea */ + ( DBENTRYP_VO ) NULL, /* sqlmixOpen */ + ( DBENTRYP_V ) NULL, /* sqlmixRelease */ + ( DBENTRYP_SP ) sqlmixStructSize, + ( DBENTRYP_CP ) NULL, /* sqlmixSysName */ + ( DBENTRYP_VEI ) NULL, /* sqlmixEval */ + ( DBENTRYP_V ) NULL, /* sqlmixPack */ + ( DBENTRYP_LSP ) NULL, /* sqlmixPackRec */ + ( DBENTRYP_VS ) NULL, /* sqlmixSort */ + ( DBENTRYP_VT ) NULL, /* sqlmixTrans */ + ( DBENTRYP_VT ) NULL, /* sqlmixTransRec */ + ( DBENTRYP_V ) NULL, /* sqlmixZap */ + ( DBENTRYP_VR ) NULL, /* sqlmixChildEnd */ + ( DBENTRYP_VR ) NULL, /* sqlmixChildStart */ + ( DBENTRYP_VR ) NULL, /* sqlmixChildSync */ + ( DBENTRYP_V ) NULL, /* sqlmixSyncChildren */ + ( DBENTRYP_V ) NULL, /* sqlmixClearRel */ + ( DBENTRYP_V ) NULL, /* sqlmixForceRel */ + ( DBENTRYP_SSP ) NULL, /* sqlmixRelArea */ + ( DBENTRYP_VR ) NULL, /* sqlmixRelEval */ + ( DBENTRYP_SI ) NULL, /* sqlmixRelText */ + ( DBENTRYP_VR ) NULL, /* sqlmixSetRel */ + ( DBENTRYP_VOI ) NULL, /* sqlmixOrderListAdd */ + ( DBENTRYP_V ) sqlmixOrderListClear, + ( DBENTRYP_VOI ) NULL, /* sqlmixOrderListDelete */ + ( DBENTRYP_VOI ) sqlmixOrderListFocus, + ( DBENTRYP_V ) NULL, /* sqlmixOrderListRebuild */ + ( DBENTRYP_VOO ) NULL, /* sqlmixOrderCondition */ + ( DBENTRYP_VOC ) sqlmixOrderCreate, + ( DBENTRYP_VOI ) NULL, /* sqlmixOrderDestroy */ + ( DBENTRYP_SVOI ) sqlmixOrderInfo, + ( DBENTRYP_V ) NULL, /* sqlmixClearFilter */ + ( DBENTRYP_V ) NULL, /* sqlmixClearLocate */ + ( DBENTRYP_V ) NULL, /* sqlmixClearScope */ + ( DBENTRYP_VPLP ) NULL, /* sqlmixCountScope */ + ( DBENTRYP_I ) NULL, /* sqlmixFilterText */ + ( DBENTRYP_SI ) NULL, /* sqlmixScopeInfo */ + ( DBENTRYP_VFI ) NULL, /* sqlmixSetFilter */ + ( DBENTRYP_VLO ) NULL, /* sqlmixSetLocate */ + ( DBENTRYP_VOS ) NULL, /* sqlmixSetScope */ + ( DBENTRYP_VPL ) NULL, /* sqlmixSkipScope */ + ( DBENTRYP_B ) NULL, /* sqlmixLocate */ + ( DBENTRYP_CC ) NULL, /* sqlmixCompile */ + ( DBENTRYP_I ) NULL, /* sqlmixError */ + ( DBENTRYP_I ) NULL, /* sqlmixEvalBlock */ + ( DBENTRYP_VSP ) NULL, /* sqlmixRawLock */ + ( DBENTRYP_VL ) NULL, /* sqlmixLock */ + ( DBENTRYP_I ) NULL, /* sqlmixUnLock */ + ( DBENTRYP_V ) NULL, /* sqlmixCloseMemFile */ + ( DBENTRYP_VO ) NULL, /* sqlmixCreateMemFile */ + ( DBENTRYP_SCCS ) NULL, /* sqlmixGetValueFile */ + ( DBENTRYP_VO ) NULL, /* sqlmixOpenMemFile */ + ( DBENTRYP_SCCS ) NULL, /* sqlmixPutValueFile */ + ( DBENTRYP_V ) NULL, /* sqlmixReadDBHeader */ + ( DBENTRYP_V ) NULL, /* sqlmixWriteDBHeader */ + ( DBENTRYP_R ) sqlmixInit, + ( DBENTRYP_R ) sqlmixExit, + ( DBENTRYP_RVVL ) NULL, /* sqlmixDrop */ + ( DBENTRYP_RVVL ) NULL, /* sqlmixExists */ + ( DBENTRYP_RVVVL ) NULL, /* sqlmixRename */ + ( DBENTRYP_RSLV ) NULL, /* sqlmixRddInfo */ + ( DBENTRYP_SVP ) NULL, /* sqlmixWhoCares */ +}; -HB_FUNC_EXTERN( SQLBASE ); HB_FUNC( SQLMIX ) { HB_FUNC_EXEC( SQLBASE ); } +HB_FUNC_EXTERN( SQLBASE ); HB_FUNC( SQLMIX ) +{ + HB_FUNC_EXEC( SQLBASE ); +} HB_FUNC_STATIC( SQLMIX_GETFUNCTABLE ) { - RDDFUNCS * pTable; + RDDFUNCS * pTable; HB_USHORT * puiCount, * puiSuperRddId, uiRddId; - puiCount = ( HB_USHORT * ) hb_parptr( 1 ); - pTable = ( RDDFUNCS * ) hb_parptr( 2 ); - uiRddId = ( HB_USHORT ) hb_parni( 4 ); - puiSuperRddId = ( HB_USHORT * ) hb_parptr( 5 ); + puiCount = ( HB_USHORT * ) hb_parptr( 1 ); + pTable = ( RDDFUNCS * ) hb_parptr( 2 ); + uiRddId = ( HB_USHORT ) hb_parni( 4 ); + puiSuperRddId = ( HB_USHORT * ) hb_parptr( 5 ); - if ( pTable ) + if( pTable ) { HB_ERRCODE errCode; if( puiCount ) - * puiCount = RDDFUNCSCOUNT; + *puiCount = RDDFUNCSCOUNT; errCode = hb_rddInheritEx( pTable, &sqlmixTable, &sqlmixSuper, "SQLBASE", puiSuperRddId ); - if ( errCode == HB_SUCCESS ) + if( errCode == HB_SUCCESS ) { s_uiRddIdSQLMIX = uiRddId; } @@ -2195,7 +2206,7 @@ HB_FUNC_STATIC( SQLMIX_GETFUNCTABLE ) } else { - hb_retni( HB_FAILURE ); + hb_retni( HB_FAILURE ); } } @@ -2209,19 +2220,21 @@ static void hb_sqlmixRddInit( void * cargo ) } HB_INIT_SYMBOLS_BEGIN( sqlmix__InitSymbols ) -{ "SQLMIX", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( SQLMIX )}, NULL }, -{ "SQLMIX_GETFUNCTABLE", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( SQLMIX_GETFUNCTABLE )}, NULL } +{ + "SQLMIX", { HB_FS_PUBLIC | HB_FS_LOCAL }, { HB_FUNCNAME( SQLMIX ) }, NULL +}, +{ "SQLMIX_GETFUNCTABLE", { HB_FS_PUBLIC | HB_FS_LOCAL }, { HB_FUNCNAME( SQLMIX_GETFUNCTABLE ) }, NULL } HB_INIT_SYMBOLS_END( sqlmix__InitSymbols ) HB_CALL_ON_STARTUP_BEGIN( _hb_sqlmix_rdd_init_ ) - hb_vmAtInit( hb_sqlmixRddInit, NULL ); +hb_vmAtInit( hb_sqlmixRddInit, NULL ); HB_CALL_ON_STARTUP_END( _hb_sqlmix_rdd_init_ ) #if defined( HB_PRAGMA_STARTUP ) #pragma startup sqlmix__InitSymbols #pragma startup _hb_sqlmix_rdd_init_ #elif defined( HB_DATASEG_STARTUP ) - #define HB_DATASEG_BODY HB_DATASEG_FUNC( sqlmix__InitSymbols ) \ - HB_DATASEG_FUNC( _hb_sqlmix_rdd_init_ ) + #define HB_DATASEG_BODY HB_DATASEG_FUNC( sqlmix__InitSymbols ) \ + HB_DATASEG_FUNC( _hb_sqlmix_rdd_init_ ) #include "hbiniseg.h" #endif diff --git a/harbour/contrib/sddfb/sddfb.c b/harbour/contrib/sddfb/sddfb.c index b42eb2e14c..f9faf28ca6 100644 --- a/harbour/contrib/sddfb/sddfb.c +++ b/harbour/contrib/sddfb/sddfb.c @@ -52,7 +52,7 @@ /* NOTE: Ugly hack to avoid this error when compiler with BCC 5.8.2 and above: Error E2238 C:\...\Firebird-2.1.1\include\ibase.h 82: Multiple declaration for 'intptr_t' */ #if ( defined( __BORLANDC__ ) && __BORLANDC__ >= 1410 ) - /* Prevent inclusion of from hbdefs.h */ +/* Prevent inclusion of from hbdefs.h */ #define __STDINT_H #endif @@ -71,8 +71,8 @@ typedef struct typedef struct { - isc_tr_handle hTrans; - isc_stmt_handle hStmt; + isc_tr_handle hTrans; + isc_stmt_handle hStmt; XSQLDA ISC_FAR * pSqlda; } SDDDATA; @@ -87,14 +87,14 @@ static HB_ERRCODE fbGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ); static SDDNODE firebirddd = { NULL, "FIREBIRD", - ( SDDFUNC_CONNECT ) fbConnect, + ( SDDFUNC_CONNECT ) fbConnect, ( SDDFUNC_DISCONNECT ) fbDisconnect, - ( SDDFUNC_EXECUTE ) fbExecute, - ( SDDFUNC_OPEN ) fbOpen, - ( SDDFUNC_CLOSE ) fbClose, - ( SDDFUNC_GOTO ) fbGoTo, - ( SDDFUNC_GETVALUE ) NULL, - ( SDDFUNC_GETVARLEN ) NULL + ( SDDFUNC_EXECUTE ) fbExecute, + ( SDDFUNC_OPEN ) fbOpen, + ( SDDFUNC_CLOSE ) fbClose, + ( SDDFUNC_GOTO ) fbGoTo, + ( SDDFUNC_GETVALUE ) NULL, + ( SDDFUNC_GETVARLEN ) NULL }; @@ -102,7 +102,7 @@ static void hb_firebirddd_init( void * cargo ) { HB_SYMBOL_UNUSED( cargo ); - if ( ! hb_sddRegister( &firebirddd ) || ( sizeof( isc_db_handle ) != sizeof( void * ) ) ) + if( ! hb_sddRegister( &firebirddd ) || ( sizeof( isc_db_handle ) != sizeof( void * ) ) ) { hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL ); } @@ -112,19 +112,19 @@ static void hb_firebirddd_init( void * cargo ) HB_FUNC_EXTERN( SQLBASE ); HB_FUNC( SDDFB ) { HB_FUNC_EXEC( SQLBASE ); } HB_INIT_SYMBOLS_BEGIN( firebirddd__InitSymbols ) -{ "SDDFB", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( SDDFB )}, NULL }, +{ "SDDFB", { HB_FS_PUBLIC | HB_FS_LOCAL }, { HB_FUNCNAME( SDDFB ) }, NULL }, HB_INIT_SYMBOLS_END( firebirddd__InitSymbols ) HB_CALL_ON_STARTUP_BEGIN( _hb_firebirddd_init_ ) - hb_vmAtInit( hb_firebirddd_init, NULL ); +hb_vmAtInit( hb_firebirddd_init, NULL ); HB_CALL_ON_STARTUP_END( _hb_firebirddd_init_ ) #if defined( HB_PRAGMA_STARTUP ) #pragma startup firebirddd__InitSymbols #pragma startup _hb_firebirddd_init_ #elif defined( HB_DATASEG_STARTUP ) - #define HB_DATASEG_BODY HB_DATASEG_FUNC( firebirddd__InitSymbols ) \ - HB_DATASEG_FUNC( _hb_firebirddd_init_ ) + #define HB_DATASEG_BODY HB_DATASEG_FUNC( firebirddd__InitSymbols ) \ + HB_DATASEG_FUNC( _hb_firebirddd_init_ ) #include "hbiniseg.h" #endif @@ -132,10 +132,10 @@ HB_CALL_ON_STARTUP_END( _hb_firebirddd_init_ ) /* ===================================================================================== */ static HB_USHORT hb_errRT_FireBirdDD( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ERRCODE errOsCode ) { - HB_USHORT uiAction; - PHB_ITEM pError; + HB_USHORT uiAction; + PHB_ITEM pError; - pError = hb_errRT_New( ES_ERROR, "SDDFB", errGenCode, errSubCode, szDescription, szOperation, errOsCode, EF_NONE ); + pError = hb_errRT_New( ES_ERROR, "SDDFB", errGenCode, errSubCode, szDescription, szOperation, errOsCode, EF_NONE ); uiAction = hb_errLaunch( pError ); hb_itemRelease( pError ); return uiAction; @@ -145,38 +145,38 @@ static HB_USHORT hb_errRT_FireBirdDD( HB_ERRCODE errGenCode, HB_ERRCODE errSubCo static HB_ERRCODE fbConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) { - ISC_STATUS_ARRAY status; - isc_db_handle hDb = ( isc_db_handle ) 0; - char parambuf[ 520 ]; - int i; - unsigned int ul; + ISC_STATUS_ARRAY status; + isc_db_handle hDb = ( isc_db_handle ) 0; + char parambuf[ 520 ]; + int i; + unsigned int ul; - i = 0; - parambuf[ i++ ] = isc_dpb_version1; + i = 0; + parambuf[ i++ ] = isc_dpb_version1; - parambuf[ i++ ] = isc_dpb_user_name; - ul = ( unsigned int ) hb_arrayGetCLen( pItem, 3 ); - if ( ul > 255 ) + parambuf[ i++ ] = isc_dpb_user_name; + ul = ( unsigned int ) hb_arrayGetCLen( pItem, 3 ); + if( ul > 255 ) ul = 255; - parambuf[ i++ ] = ( char ) ul; + parambuf[ i++ ] = ( char ) ul; memcpy( parambuf + i, hb_arrayGetCPtr( pItem, 3 ), ul ); - i += ul; + i += ul; - parambuf[ i++ ] = isc_dpb_password; - ul = ( unsigned int ) hb_arrayGetCLen( pItem, 4 ); - if ( ul > 255 ) + parambuf[ i++ ] = isc_dpb_password; + ul = ( unsigned int ) hb_arrayGetCLen( pItem, 4 ); + if( ul > 255 ) ul = 255; - parambuf[ i++ ] = ( char ) ul; + parambuf[ i++ ] = ( char ) ul; memcpy( parambuf + i, hb_arrayGetCPtr( pItem, 4 ), ul ); - i += ul; + i += ul; - if ( isc_attach_database( status, ( short ) hb_arrayGetCLen( pItem, 5 ), hb_arrayGetCPtr( pItem, 5 ), - &hDb, ( short ) i, parambuf ) ) + if( isc_attach_database( status, ( short ) hb_arrayGetCLen( pItem, 5 ), hb_arrayGetCPtr( pItem, 5 ), + &hDb, ( short ) i, parambuf ) ) { /* TODO: error code in status[1]; */ return HB_FAILURE; } - pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) ); + pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) ); ( ( SDDCONN * ) pConnection->pSDDConn )->hDb = hDb; /* HB_TRACE( HB_TR_ALWAYS, ("hDb=%d", hDb) ); */ return HB_SUCCESS; @@ -203,44 +203,44 @@ static HB_ERRCODE fbExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) static HB_ERRCODE fbOpen( SQLBASEAREAP pArea ) { - isc_db_handle * phDb = &( ( SDDCONN * ) pArea->pConnection->pSDDConn )->hDb; - SDDDATA * pSDDData; - ISC_STATUS_ARRAY status; - isc_tr_handle hTrans = ( isc_tr_handle ) 0; - isc_stmt_handle hStmt = ( isc_stmt_handle ) 0; - XSQLDA ISC_FAR * pSqlda; - XSQLVAR * pVar; - PHB_ITEM pItemEof, pItem; - DBFIELDINFO pFieldInfo; - HB_BOOL bError; - HB_USHORT uiFields, uiCount; - int iType; + isc_db_handle * phDb = &( ( SDDCONN * ) pArea->pConnection->pSDDConn )->hDb; + SDDDATA * pSDDData; + ISC_STATUS_ARRAY status; + isc_tr_handle hTrans = ( isc_tr_handle ) 0; + isc_stmt_handle hStmt = ( isc_stmt_handle ) 0; + XSQLDA ISC_FAR * pSqlda; + XSQLVAR * pVar; + PHB_ITEM pItemEof, pItem; + DBFIELDINFO pFieldInfo; + HB_BOOL bError; + HB_USHORT uiFields, uiCount; + int iType; - pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); - pSDDData = ( SDDDATA * ) pArea->pSDDData; + pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); + pSDDData = ( SDDDATA * ) pArea->pSDDData; memset( &status, 0, sizeof( status ) ); /* HB_TRACE( HB_TR_ALWAYS, ("db=%d", hDb) ); */ - if ( isc_start_transaction( status, &hTrans, 1, phDb, 0, NULL ) ) + if( isc_start_transaction( status, &hTrans, 1, phDb, 0, NULL ) ) { /* HB_TRACE( HB_TR_ALWAYS, ("hTrans=%d status=%ld %ld %ld %ld", ( int ) hTrans, ( long ) status[0], ( long ) status[1], ( long ) status[2], ( long ) status[3] ) ); */ hb_errRT_FireBirdDD( EG_OPEN, ESQLDD_START, "Start transaction failed", NULL, ( HB_ERRCODE ) isc_sqlcode( status ) ); return HB_FAILURE; } - if ( isc_dsql_allocate_statement( status, phDb, &hStmt ) ) + if( isc_dsql_allocate_statement( status, phDb, &hStmt ) ) { hb_errRT_FireBirdDD( EG_OPEN, ESQLDD_STMTALLOC, "Allocate statement failed", NULL, ( HB_ERRCODE ) isc_sqlcode( status ) ); isc_rollback_transaction( status, &hTrans ); return HB_FAILURE; } - pSqlda = ( XSQLDA * ) hb_xgrab( XSQLDA_LENGTH( 1 ) ); - pSqlda->sqln = 1; - pSqlda->version = 1; + pSqlda = ( XSQLDA * ) hb_xgrab( XSQLDA_LENGTH( 1 ) ); + pSqlda->sqln = 1; + pSqlda->version = 1; - if ( isc_dsql_prepare( status, &hTrans, &hStmt, 0, pArea->szQuery, SQL_DIALECT_V5, pSqlda ) ) + if( isc_dsql_prepare( status, &hTrans, &hStmt, 0, pArea->szQuery, SQL_DIALECT_V5, pSqlda ) ) { hb_errRT_FireBirdDD( EG_OPEN, ESQLDD_INVALIDQUERY, "Prepare statement failed", pArea->szQuery, ( HB_ERRCODE ) isc_sqlcode( status ) ); isc_dsql_free_statement( status, &hStmt, DSQL_drop ); @@ -248,15 +248,15 @@ static HB_ERRCODE fbOpen( SQLBASEAREAP pArea ) hb_xfree( pSqlda ); return HB_FAILURE; } - if ( pSqlda->sqld > pSqlda->sqln ) + if( pSqlda->sqld > pSqlda->sqln ) { - uiFields = pSqlda->sqld; - hb_xfree( pSqlda ); - pSqlda = ( XSQLDA * ) hb_xgrab( XSQLDA_LENGTH( uiFields ) ); - pSqlda->sqln = uiFields; - pSqlda->version = 1; + uiFields = pSqlda->sqld; + hb_xfree( pSqlda ); + pSqlda = ( XSQLDA * ) hb_xgrab( XSQLDA_LENGTH( uiFields ) ); + pSqlda->sqln = uiFields; + pSqlda->version = 1; - if ( isc_dsql_describe( status, &hStmt, SQL_DIALECT_V5, pSqlda ) ) + if( isc_dsql_describe( status, &hStmt, SQL_DIALECT_V5, pSqlda ) ) { hb_errRT_FireBirdDD( EG_OPEN, ESQLDD_STMTDESCR, "Describe statement failed", NULL, ( HB_ERRCODE ) isc_sqlcode( status ) ); isc_dsql_free_statement( status, &hStmt, DSQL_drop ); @@ -266,17 +266,17 @@ static HB_ERRCODE fbOpen( SQLBASEAREAP pArea ) } } - pSDDData->hTrans = hTrans; - pSDDData->hStmt = hStmt; - pSDDData->pSqlda = pSqlda; + pSDDData->hTrans = hTrans; + pSDDData->hStmt = hStmt; + pSDDData->pSqlda = pSqlda; - uiFields = pSqlda->sqld; + uiFields = pSqlda->sqld; SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields ); - pItemEof = hb_itemArrayNew( uiFields ); + pItemEof = hb_itemArrayNew( uiFields ); - bError = HB_FALSE; - for ( uiCount = 0, pVar = pSqlda->sqlvar; uiCount < uiFields; uiCount++, pVar++ ) + bError = HB_FALSE; + for( uiCount = 0, pVar = pSqlda->sqlvar; uiCount < uiFields; uiCount++, pVar++ ) { /* FIXME: if pVar->sqlname is ended with 0 byte then this hb_strndup() * and hb_xfree() bewlow is redundant and @@ -284,75 +284,75 @@ static HB_ERRCODE fbOpen( SQLBASEAREAP pArea ) * is enough. */ char * szOurName = hb_strndup( pVar->sqlname, pVar->sqlname_length ); - pFieldInfo.atomName = szOurName; + pFieldInfo.atomName = szOurName; - pFieldInfo.uiDec = 0; + pFieldInfo.uiDec = 0; - iType = pVar->sqltype & ~1; + iType = pVar->sqltype & ~1; switch( iType ) { case SQL_TEXT: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = pVar->sqllen; - pVar->sqldata = ( char* ) hb_xgrab( sizeof( char ) * pVar->sqllen + 2 ); + pFieldInfo.uiLen = pVar->sqllen; + pVar->sqldata = ( char * ) hb_xgrab( sizeof( char ) * pVar->sqllen + 2 ); break; case SQL_VARYING: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = pVar->sqllen; + pFieldInfo.uiLen = pVar->sqllen; /* pVar->sqltype = SQL_TEXT; Coercing */ - pVar->sqldata = ( char* ) hb_xgrab( sizeof( char ) * pVar->sqllen + 2 ); + pVar->sqldata = ( char * ) hb_xgrab( sizeof( char ) * pVar->sqllen + 2 ); break; case SQL_SHORT: pFieldInfo.uiType = HB_FT_INTEGER; - pFieldInfo.uiLen = 6; - pVar->sqldata = ( char* ) hb_xgrab( sizeof( short ) ); + pFieldInfo.uiLen = 6; + pVar->sqldata = ( char * ) hb_xgrab( sizeof( short ) ); break; case SQL_LONG: pFieldInfo.uiType = HB_FT_LONG; - pFieldInfo.uiLen = 10; - pVar->sqldata = ( char* ) hb_xgrab( sizeof( long ) ); + pFieldInfo.uiLen = 10; + pVar->sqldata = ( char * ) hb_xgrab( sizeof( long ) ); break; case SQL_FLOAT: pFieldInfo.uiType = HB_FT_FLOAT; - pFieldInfo.uiLen = 16; - pFieldInfo.uiDec = - pVar->sqlscale; - pVar->sqldata = ( char* ) hb_xgrab( sizeof( float ) ); + pFieldInfo.uiLen = 16; + pFieldInfo.uiDec = -pVar->sqlscale; + pVar->sqldata = ( char * ) hb_xgrab( sizeof( float ) ); break; case SQL_DOUBLE: pFieldInfo.uiType = HB_FT_DOUBLE; - pFieldInfo.uiLen = 16; - pFieldInfo.uiDec = - pVar->sqlscale; - pVar->sqldata = ( char* ) hb_xgrab( sizeof( double ) ); + pFieldInfo.uiLen = 16; + pFieldInfo.uiDec = -pVar->sqlscale; + pVar->sqldata = ( char * ) hb_xgrab( sizeof( double ) ); break; default: /* other fields as binary string */ pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = pVar->sqllen; - pVar->sqldata = ( char* ) hb_xgrab( sizeof( char ) * pVar->sqllen ); + pFieldInfo.uiLen = pVar->sqllen; + pVar->sqldata = ( char * ) hb_xgrab( sizeof( char ) * pVar->sqllen ); break; } - if ( pVar->sqltype & 1 ) + if( pVar->sqltype & 1 ) pVar->sqlind = ( short * ) hb_xgrab( sizeof( short ) ); - if ( ! bError ) + if( ! bError ) { - switch ( pFieldInfo.uiType ) + switch( pFieldInfo.uiType ) { case HB_FT_STRING: { char * pStr; - pStr = ( char * ) hb_xgrab( pFieldInfo.uiLen + 1 ); + pStr = ( char * ) hb_xgrab( pFieldInfo.uiLen + 1 ); memset( pStr, ' ', pFieldInfo.uiLen ); - pStr[ pFieldInfo.uiLen ] = '\0'; + pStr[ pFieldInfo.uiLen ] = '\0'; - pItem = hb_itemPutCL( NULL, pStr, pFieldInfo.uiLen ); + pItem = hb_itemPutCL( NULL, pStr, pFieldInfo.uiLen ); hb_xfree( pStr ); break; } @@ -382,8 +382,8 @@ static HB_ERRCODE fbOpen( SQLBASEAREAP pArea ) break; default: - pItem = hb_itemNew( NULL ); - bError = HB_TRUE; + pItem = hb_itemNew( NULL ); + bError = HB_TRUE; break; } @@ -394,18 +394,18 @@ static HB_ERRCODE fbOpen( SQLBASEAREAP pArea ) { pFieldInfo.uiType = HB_IT_LONG; } -*/ - if ( ! bError ) + */ + if( ! bError ) bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE ); } hb_xfree( szOurName ); - if ( bError ) - break; + if( bError ) + break; } - if ( bError ) + if( bError ) { hb_itemClear( pItemEof ); hb_itemRelease( pItemEof ); @@ -413,15 +413,15 @@ static HB_ERRCODE fbOpen( SQLBASEAREAP pArea ) return HB_FAILURE; } - pArea->ulRecCount = 0; + pArea->ulRecCount = 0; - pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) ); - pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); + pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) ); + pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); memset( pArea->pRowFlags, 0, SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); - pArea->ulRecMax = SQLDD_ROWSET_INIT; + pArea->ulRecMax = SQLDD_ROWSET_INIT; - * pArea->pRow = pItemEof; - pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; + *pArea->pRow = pItemEof; + pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; return HB_SUCCESS; } @@ -429,20 +429,20 @@ static HB_ERRCODE fbOpen( SQLBASEAREAP pArea ) static HB_ERRCODE fbClose( SQLBASEAREAP pArea ) { - SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData; - ISC_STATUS_ARRAY status; + SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData; + ISC_STATUS_ARRAY status; if( pSDDData ) { - if ( pSDDData->pSqlda ) + if( pSDDData->pSqlda ) { hb_xfree( pSDDData->pSqlda ); } - if ( pSDDData->hStmt ) + if( pSDDData->hStmt ) { isc_dsql_free_statement( status, &pSDDData->hStmt, DSQL_drop ); } - if ( pSDDData->hTrans ) + if( pSDDData->hTrans ) { isc_rollback_transaction( status, &pSDDData->hTrans ); } @@ -455,57 +455,57 @@ static HB_ERRCODE fbClose( SQLBASEAREAP pArea ) static HB_ERRCODE fbGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) { - SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData; - ISC_STATUS_ARRAY status; - XSQLVAR * pVar; - PHB_ITEM pItem, pArray; - HB_USHORT ui; - ISC_STATUS lErr; - short iType; + SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData; + ISC_STATUS_ARRAY status; + XSQLVAR * pVar; + PHB_ITEM pItem, pArray; + HB_USHORT ui; + ISC_STATUS lErr; + short iType; - while ( ulRecNo > pArea->ulRecCount && ! pArea->fFetched ) + while( ulRecNo > pArea->ulRecCount && ! pArea->fFetched ) { - isc_stmt_handle * phStmt = &pSDDData->hStmt; - isc_tr_handle * phTr = &pSDDData->hTrans; + isc_stmt_handle * phStmt = &pSDDData->hStmt; + isc_tr_handle * phTr = &pSDDData->hTrans; lErr = isc_dsql_fetch( status, phStmt, SQL_DIALECT_V5, pSDDData->pSqlda ); - if ( lErr == 0 ) + if( lErr == 0 ) { pArray = hb_itemArrayNew( pArea->area.uiFieldCount ); - for ( ui = 1; ui <= pArea->area.uiFieldCount; ui++ ) + for( ui = 1; ui <= pArea->area.uiFieldCount; ui++ ) { - pVar = ( XSQLVAR * ) pSDDData->pSqlda; - pVar += ( ui - 1 ); + pVar = ( XSQLVAR * ) pSDDData->pSqlda; + pVar += ( ui - 1 ); - if ( ( pVar->sqltype & 1 ) && ( * pVar->sqlind < 0 ) ) + if( ( pVar->sqltype & 1 ) && ( *pVar->sqlind < 0 ) ) continue; /* NIL value */ iType = pVar->sqltype; - switch ( iType ) + switch( iType ) { case SQL_TEXT: pItem = hb_itemPutCL( NULL, pVar->sqldata, pVar->sqllen ); break; case SQL_VARYING: - pItem = hb_itemPutCL( NULL, pVar->sqldata + 2, * ( short * ) pVar->sqldata ); + pItem = hb_itemPutCL( NULL, pVar->sqldata + 2, *( short * ) pVar->sqldata ); break; case SQL_SHORT: - pItem = hb_itemPutNI( NULL, * ( short * ) pVar->sqldata ); + pItem = hb_itemPutNI( NULL, *( short * ) pVar->sqldata ); break; case SQL_LONG: - pItem = hb_itemPutNL( NULL, * ( long * ) pVar->sqldata ); + pItem = hb_itemPutNL( NULL, *( long * ) pVar->sqldata ); break; case SQL_FLOAT: - pItem = hb_itemPutND( NULL, * ( float * ) pVar->sqldata ); + pItem = hb_itemPutND( NULL, *( float * ) pVar->sqldata ); break; case SQL_DOUBLE: - pItem = hb_itemPutND( NULL, * ( double * ) pVar->sqldata ); + pItem = hb_itemPutND( NULL, *( double * ) pVar->sqldata ); break; default: @@ -516,36 +516,36 @@ static HB_ERRCODE fbGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) hb_itemRelease( pItem ); } - if ( pArea->ulRecCount + 1 <= pArea->ulRecMax ) + if( pArea->ulRecCount + 1 <= pArea->ulRecMax ) { - pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) ); - pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) ); - pArea->ulRecMax += SQLDD_ROWSET_RESIZE; + pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) ); + pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) ); + pArea->ulRecMax += SQLDD_ROWSET_RESIZE; } pArea->ulRecCount++; - pArea->pRow[ pArea->ulRecCount ] = pArray; - pArea->pRowFlags[ pArea->ulRecCount ] = SQLDD_FLAG_CACHED; + pArea->pRow[ pArea->ulRecCount ] = pArray; + pArea->pRowFlags[ pArea->ulRecCount ] = SQLDD_FLAG_CACHED; } - else if ( lErr == 100L ) + else if( lErr == 100L ) { pArea->fFetched = HB_TRUE; - if ( isc_dsql_free_statement( status, phStmt, DSQL_drop ) ) + if( isc_dsql_free_statement( status, phStmt, DSQL_drop ) ) { hb_errRT_FireBirdDD( EG_OPEN, ESQLDD_STMTFREE, "Statement free error", NULL, ( HB_ERRCODE ) isc_sqlcode( status ) ); return HB_FAILURE; } pSDDData->hStmt = ( isc_stmt_handle ) 0; - if ( isc_commit_transaction( status, phTr ) ) + if( isc_commit_transaction( status, phTr ) ) { hb_errRT_FireBirdDD( EG_OPEN, ESQLDD_COMMIT, "Transaction commit error", NULL, ( HB_ERRCODE ) isc_sqlcode( status ) ); return HB_FAILURE; } - pSDDData->hTrans = ( isc_tr_handle ) 0; + pSDDData->hTrans = ( isc_tr_handle ) 0; hb_xfree( pSDDData->pSqlda ); /* TODO: free is more complex */ - pSDDData->pSqlda = NULL; + pSDDData->pSqlda = NULL; } else @@ -555,17 +555,17 @@ static HB_ERRCODE fbGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) } } - if ( ulRecNo == 0 || ulRecNo > pArea->ulRecCount ) + if( ulRecNo == 0 || ulRecNo > pArea->ulRecCount ) { - pArea->pRecord = pArea->pRow[ 0 ]; - pArea->bRecordFlags = pArea->pRowFlags[ 0 ]; - pArea->fPositioned = HB_FALSE; + pArea->pRecord = pArea->pRow[ 0 ]; + pArea->bRecordFlags = pArea->pRowFlags[ 0 ]; + pArea->fPositioned = HB_FALSE; } else { - pArea->pRecord = pArea->pRow[ ulRecNo ]; - pArea->bRecordFlags = pArea->pRowFlags[ ulRecNo ]; - pArea->fPositioned = HB_TRUE; + pArea->pRecord = pArea->pRow[ ulRecNo ]; + pArea->bRecordFlags = pArea->pRowFlags[ ulRecNo ]; + pArea->fPositioned = HB_TRUE; } return HB_SUCCESS; } diff --git a/harbour/contrib/sddmy/sddmy.c b/harbour/contrib/sddmy/sddmy.c index 4d0edd504e..3b519a02b5 100644 --- a/harbour/contrib/sddmy/sddmy.c +++ b/harbour/contrib/sddmy/sddmy.c @@ -63,7 +63,7 @@ typedef int my_socket; #include "mysql.h" #ifndef MYSQL_TYPE_NEWDECIMAL -#define MYSQL_TYPE_NEWDECIMAL 246 +#define MYSQL_TYPE_NEWDECIMAL 246 #endif @@ -74,8 +74,8 @@ typedef struct typedef struct { - MYSQL_RES * pResult; - MYSQL_ROW pNatRecord; + MYSQL_RES * pResult; + MYSQL_ROW pNatRecord; unsigned long * pNatLength; } SDDDATA; @@ -93,14 +93,14 @@ static SDDNODE mysqldd = { NULL, "MYSQL", - ( SDDFUNC_CONNECT ) mysqlConnect, + ( SDDFUNC_CONNECT ) mysqlConnect, ( SDDFUNC_DISCONNECT ) mysqlDisconnect, - ( SDDFUNC_EXECUTE ) mysqlExecute, - ( SDDFUNC_OPEN ) mysqlOpen, - ( SDDFUNC_CLOSE ) mysqlClose, - ( SDDFUNC_GOTO ) mysqlGoTo, - ( SDDFUNC_GETVALUE ) mysqlGetValue, - ( SDDFUNC_GETVARLEN ) NULL + ( SDDFUNC_EXECUTE ) mysqlExecute, + ( SDDFUNC_OPEN ) mysqlOpen, + ( SDDFUNC_CLOSE ) mysqlClose, + ( SDDFUNC_GOTO ) mysqlGoTo, + ( SDDFUNC_GETVALUE ) mysqlGetValue, + ( SDDFUNC_GETVARLEN ) NULL }; @@ -108,8 +108,8 @@ static void hb_mysqldd_init( void * cargo ) { HB_SYMBOL_UNUSED( cargo ); - if ( ! hb_sddRegister( & mysqldd ) || - ( sizeof( MYSQL_ROW_OFFSET ) != sizeof( void * ) ) ) + if( ! hb_sddRegister( &mysqldd ) || + ( sizeof( MYSQL_ROW_OFFSET ) != sizeof( void * ) ) ) { hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL ); } @@ -119,19 +119,19 @@ static void hb_mysqldd_init( void * cargo ) HB_FUNC_EXTERN( SQLBASE ); HB_FUNC( SDDMY ) { HB_FUNC_EXEC( SQLBASE ); } HB_INIT_SYMBOLS_BEGIN( mysqldd__InitSymbols ) -{ "SDDMY", {HB_FS_PUBLIC}, {HB_FUNCNAME( SDDMY )}, NULL }, +{ "SDDMY", { HB_FS_PUBLIC }, { HB_FUNCNAME( SDDMY ) }, NULL }, HB_INIT_SYMBOLS_END( mysqldd__InitSymbols ) HB_CALL_ON_STARTUP_BEGIN( _hb_mysqldd_init_ ) - hb_vmAtInit( hb_mysqldd_init, NULL ); +hb_vmAtInit( hb_mysqldd_init, NULL ); HB_CALL_ON_STARTUP_END( _hb_mysqldd_init_ ) #if defined( HB_PRAGMA_STARTUP ) #pragma startup mysqldd__InitSymbols #pragma startup _hb_mysqldd_init_ #elif defined( HB_DATASEG_STARTUP ) - #define HB_DATASEG_BODY HB_DATASEG_FUNC( mysqldd__InitSymbols ) \ - HB_DATASEG_FUNC( _hb_mysqldd_init_ ) + #define HB_DATASEG_BODY HB_DATASEG_FUNC( mysqldd__InitSymbols ) \ + HB_DATASEG_FUNC( _hb_mysqldd_init_ ) #include "hbiniseg.h" #endif @@ -139,10 +139,10 @@ HB_CALL_ON_STARTUP_END( _hb_mysqldd_init_ ) /*=====================================================================================*/ static HB_USHORT hb_errRT_MySQLDD( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ERRCODE errOsCode ) { - HB_USHORT uiAction; - PHB_ITEM pError; + HB_USHORT uiAction; + PHB_ITEM pError; - pError = hb_errRT_New( ES_ERROR, "SDDMY", errGenCode, errSubCode, szDescription, szOperation, errOsCode, EF_NONE ); + pError = hb_errRT_New( ES_ERROR, "SDDMY", errGenCode, errSubCode, szDescription, szOperation, errOsCode, EF_NONE ); uiAction = hb_errLaunch( pError ); hb_itemRelease( pError ); return uiAction; @@ -152,24 +152,24 @@ static HB_USHORT hb_errRT_MySQLDD( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, static HB_ERRCODE mysqlConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) { - MYSQL * pMySql; + MYSQL * pMySql; PHB_ITEM pItemUnixSocket = hb_arrayGetItemPtr( pItem, 7 ); pMySql = mysql_init( NULL ); - if ( ! mysql_real_connect( pMySql, - hb_arrayGetCPtr( pItem, 2 ) /* host */, - hb_arrayGetCPtr( pItem, 3 ) /* user */, - hb_arrayGetCPtr( pItem, 4 ) /* password */, - hb_arrayGetCPtr( pItem, 5 ) /* db */, - hb_arrayGetNI( pItem, 6 ) /* port */, - pItemUnixSocket && HB_IS_STRING( pItemUnixSocket ) ? hb_itemGetCPtr( pItemUnixSocket ) : NULL, - hb_arrayGetNI( pItem, 8 ) /* flags*/ ) ) + if( ! mysql_real_connect( pMySql, + hb_arrayGetCPtr( pItem, 2 ) /* host */, + hb_arrayGetCPtr( pItem, 3 ) /* user */, + hb_arrayGetCPtr( pItem, 4 ) /* password */, + hb_arrayGetCPtr( pItem, 5 ) /* db */, + hb_arrayGetNI( pItem, 6 ) /* port */, + pItemUnixSocket && HB_IS_STRING( pItemUnixSocket ) ? hb_itemGetCPtr( pItemUnixSocket ) : NULL, + hb_arrayGetNI( pItem, 8 ) /* flags*/ ) ) { hb_rddsqlSetError( mysql_errno( pMySql ), mysql_error( pMySql ), NULL, NULL, 0 ); mysql_close( pMySql ); return HB_FAILURE; } - pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) ); + pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) ); ( ( SDDCONN * ) pConnection->pSDDConn )->pMySql = pMySql; return HB_SUCCESS; } @@ -185,19 +185,19 @@ static HB_ERRCODE mysqlDisconnect( SQLDDCONNECTION * pConnection ) static HB_ERRCODE mysqlExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) { - MYSQL * pMySql = ( ( SDDCONN * ) pConnection->pSDDConn )->pMySql; - MYSQL_RES * pResult; - HB_ULONG ulAffectedRows; - PHB_ITEM pNewID = NULL; + MYSQL * pMySql = ( ( SDDCONN * ) pConnection->pSDDConn )->pMySql; + MYSQL_RES * pResult; + HB_ULONG ulAffectedRows; + PHB_ITEM pNewID = NULL; - if ( mysql_real_query( pMySql, hb_itemGetCPtr( pItem ), ( unsigned long ) hb_itemGetCLen( pItem ) ) ) + if( mysql_real_query( pMySql, hb_itemGetCPtr( pItem ), ( unsigned long ) hb_itemGetCLen( pItem ) ) ) { hb_rddsqlSetError( mysql_errno( pMySql ), mysql_error( pMySql ), hb_itemGetCPtr( pItem ), NULL, 0 ); return HB_FAILURE; } pResult = mysql_store_result( pMySql ); - if ( pResult ) + if( pResult ) { ulAffectedRows = ( HB_ULONG ) mysql_num_rows( pResult ); mysql_free_result( pResult ); @@ -205,7 +205,7 @@ static HB_ERRCODE mysqlExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) } else { - if ( mysql_field_count( pMySql ) == 0 ) + if( mysql_field_count( pMySql ) == 0 ) { ulAffectedRows = ( HB_ULONG ) mysql_affected_rows( pMySql ); if( mysql_insert_id( pMySql ) != 0 ) @@ -228,28 +228,28 @@ static HB_ERRCODE mysqlExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea ) { - MYSQL * pMySql = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pMySql; - SDDDATA * pSDDData; - PHB_ITEM pItemEof, pItem; - HB_ULONG ulIndex; - HB_USHORT uiFields, uiCount; - HB_ERRCODE errCode = 0; - HB_BOOL bError; - DBFIELDINFO pFieldInfo; - MYSQL_FIELD * pMyField; - void ** pRow; + MYSQL * pMySql = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pMySql; + SDDDATA * pSDDData; + PHB_ITEM pItemEof, pItem; + HB_ULONG ulIndex; + HB_USHORT uiFields, uiCount; + HB_ERRCODE errCode = 0; + HB_BOOL bError; + DBFIELDINFO pFieldInfo; + MYSQL_FIELD * pMyField; + void ** pRow; - pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); - pSDDData = ( SDDDATA * ) pArea->pSDDData; + pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); + pSDDData = ( SDDDATA * ) pArea->pSDDData; - if ( mysql_real_query( pMySql, pArea->szQuery, ( unsigned long ) strlen( pArea->szQuery ) ) ) + if( mysql_real_query( pMySql, pArea->szQuery, ( unsigned long ) strlen( pArea->szQuery ) ) ) { hb_errRT_MySQLDD( EG_OPEN, ESQLDD_INVALIDQUERY, ( const char * ) mysql_error( pMySql ), pArea->szQuery, mysql_errno( pMySql ) ); return HB_FAILURE; } - if ( ( pSDDData->pResult = mysql_store_result( pMySql ) ) == NULL ) + if( ( pSDDData->pResult = mysql_store_result( pMySql ) ) == NULL ) { hb_errRT_MySQLDD( EG_MEM, ESQLDD_INVALIDQUERY, ( const char * ) mysql_error( pMySql ), pArea->szQuery, mysql_errno( pMySql ) ); @@ -261,14 +261,14 @@ static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea ) pItemEof = hb_itemArrayNew( uiFields ); - bError = HB_FALSE; - for ( uiCount = 0; uiCount < uiFields; uiCount++ ) + bError = HB_FALSE; + for( uiCount = 0; uiCount < uiFields; uiCount++ ) { - pMyField = mysql_fetch_field_direct( pSDDData->pResult, uiCount ); + pMyField = mysql_fetch_field_direct( pSDDData->pResult, uiCount ); - pFieldInfo.atomName = pMyField->name; - pFieldInfo.uiLen = ( HB_USHORT ) pMyField->length; - pFieldInfo.uiDec = 0; + pFieldInfo.atomName = pMyField->name; + pFieldInfo.uiLen = ( HB_USHORT ) pMyField->length; + pFieldInfo.uiDec = 0; switch( pMyField->type ) { @@ -288,7 +288,7 @@ static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea ) case MYSQL_TYPE_FLOAT: case MYSQL_TYPE_DOUBLE: pFieldInfo.uiType = HB_FT_DOUBLE; - pFieldInfo.uiDec = ( HB_USHORT ) pMyField->decimals; + pFieldInfo.uiDec = ( HB_USHORT ) pMyField->decimals; break; case MYSQL_TYPE_STRING: @@ -311,12 +311,12 @@ static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea ) case MYSQL_TYPE_TIMESTAMP: case MYSQL_TYPE_DATETIME: pFieldInfo.uiType = HB_FT_TIMESTAMP; - pFieldInfo.uiLen = 8; + pFieldInfo.uiLen = 8; break; case MYSQL_TYPE_TIME: pFieldInfo.uiType = HB_FT_TIME; - pFieldInfo.uiLen = 4; + pFieldInfo.uiLen = 4; break; /* @@ -324,28 +324,28 @@ static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea ) case MYSQL_TYPE_NEWDATE: case MYSQL_TYPE_ENUM: case MYSQL_TYPE_SET: -*/ + */ default: - bError = HB_TRUE; - errCode = ( HB_ERRCODE ) pMyField->type; + bError = HB_TRUE; + errCode = ( HB_ERRCODE ) pMyField->type; pFieldInfo.uiType = 0; break; } - if ( ! bError ) + if( ! bError ) { - switch ( pFieldInfo.uiType ) + switch( pFieldInfo.uiType ) { case HB_FT_STRING: { - char* pStr; + char * pStr; - pStr = ( char * ) hb_xgrab( pFieldInfo.uiLen + 1 ); + pStr = ( char * ) hb_xgrab( pFieldInfo.uiLen + 1 ); memset( pStr, ' ', pFieldInfo.uiLen ); - pStr[ pFieldInfo.uiLen ] = '\0'; + pStr[ pFieldInfo.uiLen ] = '\0'; - pItem = hb_itemPutCL( NULL, pStr, pFieldInfo.uiLen ); + pItem = hb_itemPutCL( NULL, pStr, pFieldInfo.uiLen ); hb_xfree( pStr ); break; } @@ -376,8 +376,8 @@ static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea ) break; default: - pItem = hb_itemNew( NULL ); - bError = HB_TRUE; + pItem = hb_itemNew( NULL ); + bError = HB_TRUE; break; } @@ -389,38 +389,38 @@ static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea ) pFieldInfo.uiType = HB_IT_LONG; }*/ - if ( ! bError ) + if( ! bError ) bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE ); } - if ( bError ) + if( bError ) break; } - if ( bError ) + if( bError ) { - hb_itemRelease( pItemEof ); - hb_errRT_MySQLDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode ); - return HB_FAILURE; + hb_itemRelease( pItemEof ); + hb_errRT_MySQLDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode ); + return HB_FAILURE; } - pArea->ulRecCount = ( HB_ULONG ) mysql_num_rows( pSDDData->pResult ); + pArea->ulRecCount = ( HB_ULONG ) mysql_num_rows( pSDDData->pResult ); - pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) ); - pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) ); + pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) ); + pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) ); memset( pArea->pRowFlags, 0, ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) ); - pArea->ulRecMax = pArea->ulRecCount + 1; + pArea->ulRecMax = pArea->ulRecCount + 1; - pRow = pArea->pRow; + pRow = pArea->pRow; - *pRow = pItemEof; - pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; + *pRow = pItemEof; + pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; pRow++; - for ( ulIndex = 1; ulIndex <= pArea->ulRecCount; ulIndex++ ) + for( ulIndex = 1; ulIndex <= pArea->ulRecCount; ulIndex++ ) { - *pRow++ = ( void * ) mysql_row_tell( pSDDData->pResult ); - mysql_fetch_row( pSDDData->pResult ); + *pRow++ = ( void * ) mysql_row_tell( pSDDData->pResult ); + mysql_fetch_row( pSDDData->pResult ); } pArea->fFetched = HB_TRUE; @@ -448,19 +448,19 @@ static HB_ERRCODE mysqlGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) { SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData; - if ( ulRecNo == 0 || ulRecNo > pArea->ulRecCount ) + if( ulRecNo == 0 || ulRecNo > pArea->ulRecCount ) { - pArea->pRecord = pArea->pRow[ 0 ]; - pArea->bRecordFlags = pArea->pRowFlags[ 0 ]; + pArea->pRecord = pArea->pRow[ 0 ]; + pArea->bRecordFlags = pArea->pRowFlags[ 0 ]; - pArea->fPositioned = HB_FALSE; + pArea->fPositioned = HB_FALSE; } else { - pArea->pRecord = pArea->pRow[ ulRecNo ]; - pArea->bRecordFlags = pArea->pRowFlags[ ulRecNo ]; + pArea->pRecord = pArea->pRow[ ulRecNo ]; + pArea->bRecordFlags = pArea->pRowFlags[ ulRecNo ]; - if ( ! ( pArea->bRecordFlags & SQLDD_FLAG_CACHED ) ) + if( ! ( pArea->bRecordFlags & SQLDD_FLAG_CACHED ) ) { mysql_row_seek( pSDDData->pResult, ( MYSQL_ROW_OFFSET ) pArea->pRecord ); pSDDData->pNatRecord = mysql_fetch_row( pSDDData->pResult ); @@ -475,23 +475,23 @@ static HB_ERRCODE mysqlGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem ) { - SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData; - LPFIELD pField; - char* pValue; - char szBuffer[ 64 ]; - HB_BOOL bError; - PHB_ITEM pError; - HB_SIZE ulLen; + SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData; + LPFIELD pField; + char * pValue; + char szBuffer[ 64 ]; + HB_BOOL bError; + PHB_ITEM pError; + HB_SIZE ulLen; - bError = HB_FALSE; + bError = HB_FALSE; uiIndex--; - pField = pArea->area.lpFields + uiIndex; + pField = pArea->area.lpFields + uiIndex; - pValue = pSDDData->pNatRecord[ uiIndex ]; - ulLen = pSDDData->pNatLength[ uiIndex ]; + pValue = pSDDData->pNatRecord[ uiIndex ]; + ulLen = pSDDData->pNatLength[ uiIndex ]; /* NULL => NIL (?) */ - if ( ! pValue ) + if( ! pValue ) { hb_itemClear( pItem ); return HB_SUCCESS; @@ -502,21 +502,21 @@ static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM case HB_FT_STRING: { #if 0 - char* pStr; + char * pStr; /* Expand strings to field length */ pStr = ( char * ) hb_xgrab( pField->uiLen + 1 ); - if ( pValue ) + if( pValue ) memcpy( pStr, pValue, ulLen ); - if ( ( HB_SIZE ) pField->uiLen > ulLen ) + if( ( HB_SIZE ) pField->uiLen > ulLen ) memset( pStr + ulLen, ' ', pField->uiLen - ulLen ); pStr[ pField->uiLen ] = '\0'; hb_itemPutCRaw( pItem, pStr, pField->uiLen ); #else /* Do not expand strings */ - if ( pValue ) + if( pValue ) hb_itemPutCL( pItem, pValue, ulLen ); else hb_itemPutC( pItem, NULL ); @@ -525,7 +525,7 @@ static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM } case HB_FT_MEMO: - if ( pValue ) + if( pValue ) hb_itemPutCL( pItem, pValue, ulLen ); else hb_itemPutC( pItem, NULL ); @@ -536,33 +536,33 @@ static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM case HB_FT_INTEGER: case HB_FT_LONG: case HB_FT_DOUBLE: - if ( pValue ) + if( pValue ) { hb_strncpy( szBuffer, pValue, sizeof( szBuffer ) - 1 ); - if ( pField->uiDec ) + if( pField->uiDec ) { hb_itemPutNDLen( pItem, atof( szBuffer ), ( int ) pField->uiLen - ( ( int ) pField->uiDec + 1 ), ( int ) pField->uiDec ); } else - hb_itemPutNLLen( pItem, atol( szBuffer ), ( int ) pField->uiLen ); + hb_itemPutNLLen( pItem, atol( szBuffer ), ( int ) pField->uiLen ); } else { - if ( pField->uiDec ) + if( pField->uiDec ) hb_itemPutNDLen( pItem, 0.0, ( int ) pField->uiLen - ( ( int ) pField->uiDec + 1 ), ( int ) pField->uiDec ); else - hb_itemPutNLLen( pItem, 0, ( int ) pField->uiLen ); + hb_itemPutNLLen( pItem, 0, ( int ) pField->uiLen ); } break; case HB_FT_DATE: { - char szDate[ 9 ]; + char szDate[ 9 ]; szDate[ 0 ] = pValue[ 0 ]; szDate[ 1 ] = pValue[ 1 ]; @@ -579,19 +579,19 @@ static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM case HB_FT_TIMESTAMP: { - char szTimeStamp[ 15 ]; + char szTimeStamp[ 15 ]; - szTimeStamp[ 0 ] = pValue[ 0 ]; - szTimeStamp[ 1 ] = pValue[ 1 ]; - szTimeStamp[ 2 ] = pValue[ 2 ]; - szTimeStamp[ 3 ] = pValue[ 3 ]; - szTimeStamp[ 4 ] = pValue[ 5 ]; - szTimeStamp[ 5 ] = pValue[ 6 ]; - szTimeStamp[ 6 ] = pValue[ 8 ]; - szTimeStamp[ 7 ] = pValue[ 9 ]; + szTimeStamp[ 0 ] = pValue[ 0 ]; + szTimeStamp[ 1 ] = pValue[ 1 ]; + szTimeStamp[ 2 ] = pValue[ 2 ]; + szTimeStamp[ 3 ] = pValue[ 3 ]; + szTimeStamp[ 4 ] = pValue[ 5 ]; + szTimeStamp[ 5 ] = pValue[ 6 ]; + szTimeStamp[ 6 ] = pValue[ 8 ]; + szTimeStamp[ 7 ] = pValue[ 9 ]; - szTimeStamp[ 8 ] = pValue[ 11 ]; - szTimeStamp[ 9 ] = pValue[ 12 ]; + szTimeStamp[ 8 ] = pValue[ 11 ]; + szTimeStamp[ 9 ] = pValue[ 12 ]; szTimeStamp[ 10 ] = pValue[ 14 ]; szTimeStamp[ 11 ] = pValue[ 15 ]; szTimeStamp[ 12 ] = pValue[ 17 ]; @@ -603,19 +603,19 @@ static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM case HB_FT_TIME: { - char szTimeStamp[ 15 ]; + char szTimeStamp[ 15 ]; - szTimeStamp[ 0 ] = '0'; - szTimeStamp[ 1 ] = '0'; - szTimeStamp[ 2 ] = '0'; - szTimeStamp[ 3 ] = '0'; - szTimeStamp[ 4 ] = '0'; - szTimeStamp[ 5 ] = '0'; - szTimeStamp[ 6 ] = '0'; - szTimeStamp[ 7 ] = '0'; + szTimeStamp[ 0 ] = '0'; + szTimeStamp[ 1 ] = '0'; + szTimeStamp[ 2 ] = '0'; + szTimeStamp[ 3 ] = '0'; + szTimeStamp[ 4 ] = '0'; + szTimeStamp[ 5 ] = '0'; + szTimeStamp[ 6 ] = '0'; + szTimeStamp[ 7 ] = '0'; - szTimeStamp[ 8 ] = pValue[ 0 ]; - szTimeStamp[ 9 ] = pValue[ 1 ]; + szTimeStamp[ 8 ] = pValue[ 0 ]; + szTimeStamp[ 9 ] = pValue[ 1 ]; szTimeStamp[ 10 ] = pValue[ 3 ]; szTimeStamp[ 11 ] = pValue[ 4 ]; szTimeStamp[ 12 ] = pValue[ 6 ]; @@ -630,7 +630,7 @@ static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM break; } - if ( bError ) + if( bError ) { pError = hb_errNew(); hb_errPutGenCode( pError, EG_DATATYPE ); diff --git a/harbour/contrib/sddodbc/sddodbc.c b/harbour/contrib/sddodbc/sddodbc.c index 333b1ffe5c..52a4db14f9 100644 --- a/harbour/contrib/sddodbc/sddodbc.c +++ b/harbour/contrib/sddodbc/sddodbc.c @@ -61,7 +61,7 @@ /* Required by headers on Windows */ #if defined( HB_OS_WIN ) # include - /* Required for WIN32_LEAN_AND_MEAN mode */ +/* Required for WIN32_LEAN_AND_MEAN mode */ # if ! defined( WIN32 ) # define WIN32 # endif @@ -70,9 +70,9 @@ #include #include -#if !defined( HB_OS_WIN ) -# if !defined( SQLLEN ) && !defined( SQLTCHAR ) - typedef unsigned char SQLTCHAR; +#if ! defined( HB_OS_WIN ) +# if ! defined( SQLLEN ) && ! defined( SQLTCHAR ) +typedef unsigned char SQLTCHAR; # endif #endif @@ -95,13 +95,13 @@ typedef struct { - SQLHENV hEnv; - SQLHDBC hConn; + SQLHENV hEnv; + SQLHDBC hConn; } SDDCONN; typedef struct { - SQLHSTMT hStmt; + SQLHSTMT hStmt; } SDDDATA; static HB_ERRCODE odbcConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ); @@ -116,14 +116,14 @@ static SDDNODE odbcdd = { NULL, "ODBC", - ( SDDFUNC_CONNECT ) odbcConnect, + ( SDDFUNC_CONNECT ) odbcConnect, ( SDDFUNC_DISCONNECT ) odbcDisconnect, - ( SDDFUNC_EXECUTE ) odbcExecute, - ( SDDFUNC_OPEN ) odbcOpen, - ( SDDFUNC_CLOSE ) odbcClose, - ( SDDFUNC_GOTO ) odbcGoTo, - ( SDDFUNC_GETVALUE ) NULL, - ( SDDFUNC_GETVARLEN ) NULL + ( SDDFUNC_EXECUTE ) odbcExecute, + ( SDDFUNC_OPEN ) odbcOpen, + ( SDDFUNC_CLOSE ) odbcClose, + ( SDDFUNC_GOTO ) odbcGoTo, + ( SDDFUNC_GETVALUE ) NULL, + ( SDDFUNC_GETVARLEN ) NULL }; @@ -131,7 +131,7 @@ static void hb_odbcdd_init( void * cargo ) { HB_SYMBOL_UNUSED( cargo ); - if ( ! hb_sddRegister( & odbcdd ) ) + if( ! hb_sddRegister( &odbcdd ) ) { hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL ); } @@ -141,19 +141,19 @@ static void hb_odbcdd_init( void * cargo ) HB_FUNC_EXTERN( SQLBASE ); HB_FUNC( SDDODBC ) { HB_FUNC_EXEC( SQLBASE ); } HB_INIT_SYMBOLS_BEGIN( odbcdd__InitSymbols ) -{ "SDDODBC", {HB_FS_PUBLIC}, {HB_FUNCNAME( SDDODBC )}, NULL }, +{ "SDDODBC", { HB_FS_PUBLIC }, { HB_FUNCNAME( SDDODBC ) }, NULL }, HB_INIT_SYMBOLS_END( odbcdd__InitSymbols ) HB_CALL_ON_STARTUP_BEGIN( _hb_odbcdd_init_ ) - hb_vmAtInit( hb_odbcdd_init, NULL ); +hb_vmAtInit( hb_odbcdd_init, NULL ); HB_CALL_ON_STARTUP_END( _hb_odbcdd_init_ ) #if defined( HB_PRAGMA_STARTUP ) #pragma startup odbcdd__InitSymbols #pragma startup _hb_odbcdd_init_ #elif defined( HB_DATASEG_STARTUP ) - #define HB_DATASEG_BODY HB_DATASEG_FUNC( odbcdd__InitSymbols ) \ - HB_DATASEG_FUNC( _hb_odbcdd_init_ ) + #define HB_DATASEG_BODY HB_DATASEG_FUNC( odbcdd__InitSymbols ) \ + HB_DATASEG_FUNC( _hb_odbcdd_init_ ) #include "hbiniseg.h" #endif @@ -161,10 +161,10 @@ HB_CALL_ON_STARTUP_END( _hb_odbcdd_init_ ) /*=====================================================================================*/ static HB_USHORT hb_errRT_ODBCDD( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ERRCODE errOsCode ) { - HB_USHORT uiAction; - PHB_ITEM pError; + HB_USHORT uiAction; + PHB_ITEM pError; - pError = hb_errRT_New( ES_ERROR, "SDDODBC", errGenCode, errSubCode, szDescription, szOperation, errOsCode, EF_NONE ); + pError = hb_errRT_New( ES_ERROR, "SDDODBC", errGenCode, errSubCode, szDescription, szOperation, errOsCode, EF_NONE ); uiAction = hb_errLaunch( pError ); hb_itemRelease( pError ); return uiAction; @@ -173,26 +173,26 @@ static HB_USHORT hb_errRT_ODBCDD( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, static char * odbcGetError( SQLHENV hEnv, SQLHDBC hConn, SQLHSTMT hStmt, HB_ERRCODE * pErrCode ) { - SQLTCHAR szError[ 6 + SQL_MAX_MESSAGE_LENGTH ]; - SQLINTEGER iNativeErr = 9999; - SQLSMALLINT iLen; - char * szRet; + SQLTCHAR szError[ 6 + SQL_MAX_MESSAGE_LENGTH ]; + SQLINTEGER iNativeErr = 9999; + SQLSMALLINT iLen; + char * szRet; if( SQL_SUCCEEDED( SQLError( hEnv, hConn, hStmt, szError, &iNativeErr, szError + 6, SQL_MAX_MESSAGE_LENGTH, &iLen ) ) ) { PHB_ITEM pRet; - szError[ 5 ] = ' '; + szError[ 5 ] = ' '; - pRet = O_HB_ITEMPUTSTR( NULL, ( O_HB_CHAR * ) szError ); - szRet = hb_strdup( hb_itemGetCPtr( pRet ) ); + pRet = O_HB_ITEMPUTSTR( NULL, ( O_HB_CHAR * ) szError ); + szRet = hb_strdup( hb_itemGetCPtr( pRet ) ); hb_itemRelease( pRet ); } else szRet = hb_strdup( "HY000 Unable to get error message" ); if( pErrCode ) - * pErrCode = ( HB_ERRCODE ) iNativeErr; + *pErrCode = ( HB_ERRCODE ) iNativeErr; return szRet; } @@ -201,10 +201,10 @@ static char * odbcGetError( SQLHENV hEnv, SQLHDBC hConn, SQLHSTMT hStmt, HB_ERRC static HB_ERRCODE odbcConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) { - SQLHENV hEnv = NULL; - SQLHDBC hConnect = NULL; - char * szError; - HB_ERRCODE errCode; + SQLHENV hEnv = NULL; + SQLHDBC hConnect = NULL; + char * szError; + HB_ERRCODE errCode; if( SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv ) ) ) { @@ -212,11 +212,11 @@ static HB_ERRCODE odbcConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) if( SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_DBC, hEnv, &hConnect ) ) ) { - void * hConnStr; - SQLTCHAR cBuffer[ 1024 ]; - SQLSMALLINT iLen = HB_SIZEOFARRAY( cBuffer ); + void * hConnStr; + SQLTCHAR cBuffer[ 1024 ]; + SQLSMALLINT iLen = HB_SIZEOFARRAY( cBuffer ); - cBuffer[ 0 ] ='\0'; + cBuffer[ 0 ] = '\0'; if( SQL_SUCCEEDED( SQLDriverConnect( hConnect, NULL, @@ -228,9 +228,9 @@ static HB_ERRCODE odbcConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) SQL_DRIVER_NOPROMPT ) ) ) { hb_strfree( hConnStr ); - pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) ); - ( ( SDDCONN * ) pConnection->pSDDConn )->hConn = hConnect; - ( ( SDDCONN * ) pConnection->pSDDConn )->hEnv = hEnv; + pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) ); + ( ( SDDCONN * ) pConnection->pSDDConn )->hConn = hConnect; + ( ( SDDCONN * ) pConnection->pSDDConn )->hEnv = hEnv; return HB_SUCCESS; } else @@ -262,7 +262,7 @@ static HB_ERRCODE odbcConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) static HB_ERRCODE odbcDisconnect( SQLDDCONNECTION * pConnection ) { - SDDCONN * pSDDConn = ( SDDCONN * ) pConnection->pSDDConn; + SDDCONN * pSDDConn = ( SDDCONN * ) pConnection->pSDDConn; SQLDisconnect( pSDDConn->hConn ); SQLFreeHandle( SQL_HANDLE_DBC, pSDDConn->hConn ); @@ -274,14 +274,14 @@ static HB_ERRCODE odbcDisconnect( SQLDDCONNECTION * pConnection ) static HB_ERRCODE odbcExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) { - SDDCONN * pSDDConn = ( SDDCONN * ) pConnection->pSDDConn; - void * hStatement; - SQLHSTMT hStmt; - SQLLEN iCount; - char * szError; - HB_ERRCODE errCode; + SDDCONN * pSDDConn = ( SDDCONN * ) pConnection->pSDDConn; + void * hStatement; + SQLHSTMT hStmt; + SQLLEN iCount; + char * szError; + HB_ERRCODE errCode; - if ( ! SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_STMT, pSDDConn->hConn, &hStmt ) ) ) + if( ! SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_STMT, pSDDConn->hConn, &hStmt ) ) ) { szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, SQL_NULL_HSTMT, &errCode ); hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTALLOC, szError, hb_itemGetCPtr( pItem ), errCode ); @@ -289,13 +289,13 @@ static HB_ERRCODE odbcExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) return HB_FAILURE; } - if ( SQL_SUCCEEDED( SQLExecDirect( hStmt, - ( SQLTCHAR * ) O_HB_ITEMGETSTR( pItem, &hStatement, NULL ), - ( SQLINTEGER ) hb_itemGetCLen( pItem ) ) ) ) + if( SQL_SUCCEEDED( SQLExecDirect( hStmt, + ( SQLTCHAR * ) O_HB_ITEMGETSTR( pItem, &hStatement, NULL ), + ( SQLINTEGER ) hb_itemGetCLen( pItem ) ) ) ) { hb_strfree( hStatement ); - if ( SQL_SUCCEEDED( SQLRowCount( hStmt, &iCount ) ) ) + if( SQL_SUCCEEDED( SQLRowCount( hStmt, &iCount ) ) ) { /* TODO: new id */ hb_rddsqlSetError( 0, NULL, hb_itemGetCPtr( pItem ), NULL, ( unsigned long ) iCount ); @@ -316,21 +316,21 @@ static HB_ERRCODE odbcExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea ) { - SDDCONN * pSDDConn = ( SDDCONN * ) pArea->pConnection->pSDDConn; - SDDDATA * pSDDData; - void * hQuery; - SQLHSTMT hStmt; - SQLSMALLINT iNameLen; - PHB_ITEM pItemEof, pItem; - HB_BOOL bError; - HB_USHORT uiFields, uiIndex; - HB_ERRCODE errCode; - char * szError; + SDDCONN * pSDDConn = ( SDDCONN * ) pArea->pConnection->pSDDConn; + SDDDATA * pSDDData; + void * hQuery; + SQLHSTMT hStmt; + SQLSMALLINT iNameLen; + PHB_ITEM pItemEof, pItem; + HB_BOOL bError; + HB_USHORT uiFields, uiIndex; + HB_ERRCODE errCode; + char * szError; - pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); - pSDDData = ( SDDDATA * ) pArea->pSDDData; + pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); + pSDDData = ( SDDDATA * ) pArea->pSDDData; - if ( ! SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_STMT, pSDDConn->hConn, &hStmt ) ) ) + if( ! SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_STMT, pSDDConn->hConn, &hStmt ) ) ) { szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, SQL_NULL_HSTMT, &errCode ); hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTALLOC, szError, pArea->szQuery, errCode ); @@ -340,9 +340,9 @@ static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea ) pItem = hb_itemPutC( NULL, pArea->szQuery ); - if ( ! SQL_SUCCEEDED( SQLExecDirect( hStmt, - ( SQLTCHAR * ) O_HB_ITEMGETSTR( pItem, &hQuery, NULL ), - ( SQLINTEGER ) hb_itemGetCLen( pItem ) ) ) ) + if( ! SQL_SUCCEEDED( SQLExecDirect( hStmt, + ( SQLTCHAR * ) O_HB_ITEMGETSTR( pItem, &hQuery, NULL ), + ( SQLINTEGER ) hb_itemGetCLen( pItem ) ) ) ) { hb_strfree( hQuery ); hb_itemRelease( pItem ); @@ -358,7 +358,7 @@ static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea ) hb_itemRelease( pItem ); } - if ( ! SQL_SUCCEEDED( SQLNumResultCols( hStmt, &iNameLen ) ) ) + if( ! SQL_SUCCEEDED( SQLNumResultCols( hStmt, &iNameLen ) ) ) { szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, &errCode ); SQLFreeHandle( SQL_HANDLE_STMT, hStmt ); @@ -374,19 +374,19 @@ static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea ) /* HB_TRACE( HB_TR_ALWAYS, ("fieldcount=%d", iNameLen) ); */ - errCode = 0; - bError = HB_FALSE; - for ( uiIndex = 0; uiIndex < uiFields; uiIndex++ ) + errCode = 0; + bError = HB_FALSE; + for( uiIndex = 0; uiIndex < uiFields; uiIndex++ ) { DBFIELDINFO pFieldInfo; - PHB_ITEM pName; + PHB_ITEM pName; - SQLTCHAR cName[ 256 ]; - SQLULEN uiSize; + SQLTCHAR cName[ 256 ]; + SQLULEN uiSize; SQLSMALLINT iDataType, iDec, iNull; - if ( ! SQL_SUCCEEDED( SQLDescribeCol( hStmt, ( SQLSMALLINT ) uiIndex + 1, ( SQLTCHAR * ) cName, HB_SIZEOFARRAY( cName ), &iNameLen, &iDataType, &uiSize, &iDec, &iNull ) ) ) + if( ! SQL_SUCCEEDED( SQLDescribeCol( hStmt, ( SQLSMALLINT ) uiIndex + 1, ( SQLTCHAR * ) cName, HB_SIZEOFARRAY( cName ), &iNameLen, &iDataType, &uiSize, &iDec, &iNull ) ) ) { hb_itemRelease( pItemEof ); szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, NULL ); @@ -396,8 +396,8 @@ static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea ) return HB_FAILURE; } - pName = O_HB_ITEMPUTSTRLEN( NULL, ( O_HB_CHAR * ) cName, iNameLen ); - pFieldInfo.atomName = hb_itemGetCPtr( pName ); + pName = O_HB_ITEMPUTSTRLEN( NULL, ( O_HB_CHAR * ) cName, iNameLen ); + pFieldInfo.atomName = hb_itemGetCPtr( pName ); /* We do mapping of many SQL types to one Harbour field type here, so, we need store @@ -407,10 +407,10 @@ static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea ) if( pField->uiTypeExtended == ( HB_USHORT ) SQL_BIGINT ) or introduce our own unsigned SQL types. [Mindaugas] - */ - pFieldInfo.uiTypeExtended = ( HB_USHORT ) iDataType; - pFieldInfo.uiLen = ( HB_USHORT ) uiSize; - pFieldInfo.uiDec = iDec; + */ + pFieldInfo.uiTypeExtended = ( HB_USHORT ) iDataType; + pFieldInfo.uiLen = ( HB_USHORT ) uiSize; + pFieldInfo.uiDec = iDec; /* HB_TRACE( HB_TR_ALWAYS, ("field: name=%s type=%d len=%d dec=%d null=%d", pFieldInfo.atomName, iDataType, uiSize, iDec, iNull ) ); */ @@ -427,8 +427,8 @@ static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea ) case SQL_VARBINARY: case SQL_LONGVARBINARY: - pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiFlags = HB_FF_BINARY; + pFieldInfo.uiType = HB_FT_STRING; + pFieldInfo.uiFlags = HB_FF_BINARY; break; case SQL_TINYINT: @@ -471,26 +471,26 @@ static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea ) default: /* HB_TRACE( HB_TR_ALWAYS, ("new sql type=%d", iDataType) ); */ - bError = HB_TRUE; - errCode = ( HB_ERRCODE ) iDataType; + bError = HB_TRUE; + errCode = ( HB_ERRCODE ) iDataType; pFieldInfo.uiType = 0; pFieldInfo.uiType = HB_FT_STRING; break; } - if ( ! bError ) + if( ! bError ) { - switch ( pFieldInfo.uiType ) + switch( pFieldInfo.uiType ) { case HB_FT_STRING: { char * pStr; - pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 ); + pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 ); memset( pStr, ' ', pFieldInfo.uiLen ); - pStr[ pFieldInfo.uiLen ] = '\0'; + pStr[ pFieldInfo.uiLen ] = '\0'; - pItem = hb_itemPutCL( NULL, pStr, pFieldInfo.uiLen ); + pItem = hb_itemPutCL( NULL, pStr, pFieldInfo.uiLen ); hb_xfree( pStr ); break; } @@ -526,30 +526,30 @@ static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea ) pItem = hb_itemPutTDT( NULL, 0, 0 ); break; - case HB_FT_TIMESTAMP: + case HB_FT_TIMESTAMP: pItem = hb_itemPutTDT( NULL, 0, 0 ); break; default: - pItem = hb_itemNew( NULL ); - bError = HB_TRUE; + pItem = hb_itemNew( NULL ); + bError = HB_TRUE; break; } hb_arraySetForward( pItemEof, uiIndex + 1, pItem ); hb_itemRelease( pItem ); - if ( ! bError ) + if( ! bError ) bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE ); } hb_itemRelease( pName ); - if ( bError ) + if( bError ) break; } - if ( bError ) + if( bError ) { hb_itemRelease( pItemEof ); SQLFreeHandle( SQL_HANDLE_STMT, hStmt ); @@ -557,18 +557,18 @@ static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea ) return HB_FAILURE; } - pArea->ulRecCount = 0; - pArea->ulRecMax = SQLDD_ROWSET_INIT; + pArea->ulRecCount = 0; + pArea->ulRecMax = SQLDD_ROWSET_INIT; - pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) ); + pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) ); memset( pArea->pRow, 0, SQLDD_ROWSET_INIT * sizeof( void * ) ); - pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); + pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); memset( pArea->pRowFlags, 0, SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); - pArea->pRow[ 0 ] = pItemEof; - pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; + pArea->pRow[ 0 ] = pItemEof; + pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; - pSDDData->hStmt = hStmt; + pSDDData->hStmt = hStmt; return HB_SUCCESS; } @@ -591,14 +591,14 @@ static HB_ERRCODE odbcClose( SQLBASEAREAP pArea ) static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) { - SQLHSTMT hStmt = ( ( SDDDATA * ) pArea->pSDDData )->hStmt; - SQLRETURN res; - SQLLEN iLen; - PHB_ITEM pArray, pItem; - LPFIELD pField; - HB_USHORT ui; + SQLHSTMT hStmt = ( ( SDDDATA * ) pArea->pSDDData )->hStmt; + SQLRETURN res; + SQLLEN iLen; + PHB_ITEM pArray, pItem; + LPFIELD pField; + HB_USHORT ui; - while ( ulRecNo > pArea->ulRecCount && ! pArea->fFetched ) + while( ulRecNo > pArea->ulRecCount && ! pArea->fFetched ) { if( ! SQL_SUCCEEDED( SQLFetch( hStmt ) ) ) { @@ -607,20 +607,20 @@ static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) } pArray = hb_itemArrayNew( pArea->area.uiFieldCount ); - for ( ui = 1; ui <= pArea->area.uiFieldCount; ui++ ) + for( ui = 1; ui <= pArea->area.uiFieldCount; ui++ ) { - iLen = SQL_NULL_DATA; - pItem = NULL; - res = 0; - pField = pArea->area.lpFields + ui - 1; + iLen = SQL_NULL_DATA; + pItem = NULL; + res = 0; + pField = pArea->area.lpFields + ui - 1; switch( pField->uiType ) { case HB_FT_STRING: { SQLSMALLINT iTargetType; - char buffer[ 2 ]; + char buffer[ 2 ]; - iLen = 0; + iLen = 0; #if defined( UNICODE ) iTargetType = SQL_C_WCHAR; @@ -636,7 +636,7 @@ static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, iTargetType, val, iLen + sizeof( O_HB_CHAR ), &iLen ) ) ) { #if defined( UNICODE ) - iLen /= 2; + iLen /= 2; #endif pItem = O_HB_ITEMPUTSTRLEN( NULL, ( O_HB_CHAR * ) val, ( HB_SIZE ) iLen ); } @@ -647,7 +647,6 @@ static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) } case HB_FT_INTEGER: - { if( pField->uiTypeExtended == ( HB_USHORT ) SQL_BIGINT ) { HB_I64 val = 0; @@ -665,7 +664,6 @@ static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) } } break; - } case HB_FT_LONG: if( pField->uiDec == 0 ) @@ -755,29 +753,29 @@ static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) hb_itemRelease( pItem ); } } - if ( pArea->ulRecCount + 1 <= pArea->ulRecMax ) + if( pArea->ulRecCount + 1 <= pArea->ulRecMax ) { - pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) ); - pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) ); - pArea->ulRecMax += SQLDD_ROWSET_RESIZE; + pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) ); + pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) ); + pArea->ulRecMax += SQLDD_ROWSET_RESIZE; } pArea->ulRecCount++; - pArea->pRow[ pArea->ulRecCount ] = pArray; - pArea->pRowFlags[ pArea->ulRecCount ] = SQLDD_FLAG_CACHED; + pArea->pRow[ pArea->ulRecCount ] = pArray; + pArea->pRowFlags[ pArea->ulRecCount ] = SQLDD_FLAG_CACHED; } - if ( ulRecNo == 0 || ulRecNo > pArea->ulRecCount ) + if( ulRecNo == 0 || ulRecNo > pArea->ulRecCount ) { - pArea->pRecord = pArea->pRow[ 0 ]; - pArea->bRecordFlags = pArea->pRowFlags[ 0 ]; - pArea->fPositioned = HB_FALSE; + pArea->pRecord = pArea->pRow[ 0 ]; + pArea->bRecordFlags = pArea->pRowFlags[ 0 ]; + pArea->fPositioned = HB_FALSE; } else { - pArea->pRecord = pArea->pRow[ ulRecNo ]; - pArea->bRecordFlags = pArea->pRowFlags[ ulRecNo ]; - pArea->fPositioned = HB_TRUE; + pArea->pRecord = pArea->pRow[ ulRecNo ]; + pArea->bRecordFlags = pArea->pRowFlags[ ulRecNo ]; + pArea->fPositioned = HB_TRUE; } return HB_SUCCESS; } diff --git a/harbour/contrib/sddpg/sddpg.c b/harbour/contrib/sddpg/sddpg.c index 684565150c..93d52ae57a 100644 --- a/harbour/contrib/sddpg/sddpg.c +++ b/harbour/contrib/sddpg/sddpg.c @@ -58,31 +58,31 @@ #include "libpq-fe.h" -#define BOOLOID 16 -#define BYTEAOID 17 -#define CHAROID 18 -#define NAMEOID 19 -#define INT8OID 20 -#define INT2OID 21 -#define INT4OID 23 -#define TEXTOID 25 -#define OIDOID 26 -#define CIDROID 650 -#define FLOAT4OID 700 -#define FLOAT8OID 701 -#define CASHOID 790 -#define MACADDROID 829 -#define INETOID 869 -#define BPCHAROID 1042 -#define VARCHAROID 1043 -#define DATEOID 1082 -#define TIMEOID 1083 -#define TIMESTAMPOID 1114 -#define TIMESTAMPTZOID 1184 -#define TIMETZOID 1266 -#define BITOID 1560 -#define VARBITOID 1562 -#define NUMERICOID 1700 +#define BOOLOID 16 +#define BYTEAOID 17 +#define CHAROID 18 +#define NAMEOID 19 +#define INT8OID 20 +#define INT2OID 21 +#define INT4OID 23 +#define TEXTOID 25 +#define OIDOID 26 +#define CIDROID 650 +#define FLOAT4OID 700 +#define FLOAT8OID 701 +#define CASHOID 790 +#define MACADDROID 829 +#define INETOID 869 +#define BPCHAROID 1042 +#define VARCHAROID 1043 +#define DATEOID 1082 +#define TIMEOID 1083 +#define TIMESTAMPOID 1114 +#define TIMESTAMPTZOID 1184 +#define TIMETZOID 1266 +#define BITOID 1560 +#define VARBITOID 1562 +#define NUMERICOID 1700 typedef struct { @@ -106,14 +106,14 @@ static HB_ERRCODE pgsqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM static SDDNODE pgsqldd = { NULL, "POSTGRESQL", - ( SDDFUNC_CONNECT ) pgsqlConnect, + ( SDDFUNC_CONNECT ) pgsqlConnect, ( SDDFUNC_DISCONNECT ) pgsqlDisconnect, - ( SDDFUNC_EXECUTE ) pgsqlExecute, - ( SDDFUNC_OPEN ) pgsqlOpen, - ( SDDFUNC_CLOSE ) pgsqlClose, - ( SDDFUNC_GOTO ) NULL, - ( SDDFUNC_GETVALUE ) pgsqlGetValue, - ( SDDFUNC_GETVARLEN ) NULL + ( SDDFUNC_EXECUTE ) pgsqlExecute, + ( SDDFUNC_OPEN ) pgsqlOpen, + ( SDDFUNC_CLOSE ) pgsqlClose, + ( SDDFUNC_GOTO ) NULL, + ( SDDFUNC_GETVALUE ) pgsqlGetValue, + ( SDDFUNC_GETVARLEN ) NULL }; @@ -121,7 +121,7 @@ static void hb_pgsqldd_init( void * cargo ) { HB_SYMBOL_UNUSED( cargo ); - if ( ! hb_sddRegister( & pgsqldd ) ) + if( ! hb_sddRegister( &pgsqldd ) ) { hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL ); } @@ -131,19 +131,19 @@ static void hb_pgsqldd_init( void * cargo ) HB_FUNC_EXTERN( SQLBASE ); HB_FUNC( SDDPG ) { HB_FUNC_EXEC( SQLBASE ); } HB_INIT_SYMBOLS_BEGIN( sddpostgre__InitSymbols ) -{ "SDDPG", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( SDDPG )}, NULL }, +{ "SDDPG", { HB_FS_PUBLIC | HB_FS_LOCAL }, { HB_FUNCNAME( SDDPG ) }, NULL }, HB_INIT_SYMBOLS_END( sddpostgre__InitSymbols ) HB_CALL_ON_STARTUP_BEGIN( _hb_sddpostgre_init_ ) - hb_vmAtInit( hb_pgsqldd_init, NULL ); +hb_vmAtInit( hb_pgsqldd_init, NULL ); HB_CALL_ON_STARTUP_END( _hb_sddpostgre_init_ ) #if defined( HB_PRAGMA_STARTUP ) #pragma startup sddpostgre__InitSymbols #pragma startup _hb_sddpostgre_init_ #elif defined( HB_DATASEG_STARTUP ) - #define HB_DATASEG_BODY HB_DATASEG_FUNC( sddpostgre__InitSymbols ) \ - HB_DATASEG_FUNC( _hb_sddpostgre_init_ ) + #define HB_DATASEG_BODY HB_DATASEG_FUNC( sddpostgre__InitSymbols ) \ + HB_DATASEG_FUNC( _hb_sddpostgre_init_ ) #include "hbiniseg.h" #endif @@ -151,10 +151,10 @@ HB_CALL_ON_STARTUP_END( _hb_sddpostgre_init_ ) /* ===================================================================================== */ static HB_USHORT hb_errRT_PostgreSQLDD( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ERRCODE errOsCode ) { - HB_USHORT uiAction; - PHB_ITEM pError; + HB_USHORT uiAction; + PHB_ITEM pError; - pError = hb_errRT_New( ES_ERROR, "SDDPG", errGenCode, errSubCode, szDescription, szOperation, errOsCode, EF_NONE ); + pError = hb_errRT_New( ES_ERROR, "SDDPG", errGenCode, errSubCode, szDescription, szOperation, errOsCode, EF_NONE ); uiAction = hb_errLaunch( pError ); hb_itemRelease( pError ); return uiAction; @@ -165,25 +165,25 @@ static HB_USHORT hb_errRT_PostgreSQLDD( HB_ERRCODE errGenCode, HB_ERRCODE errSub static HB_ERRCODE pgsqlConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) { - PGconn * pConn; - ConnStatusType status; + PGconn * pConn; + ConnStatusType status; pConn = PQsetdbLogin( hb_arrayGetCPtr( pItem, 2 ), NULL, NULL, NULL, hb_arrayGetCPtr( pItem, 5 ), hb_arrayGetCPtr( pItem, 3 ), hb_arrayGetCPtr( pItem, 4 ) ); - if ( ! pConn ) /* Low memory, etc */ + if( ! pConn ) /* Low memory, etc */ { /* TODO: error */ return HB_FAILURE; } status = PQstatus( pConn ); - if ( status != CONNECTION_OK ) + if( status != CONNECTION_OK ) { /* TODO: error */ PQfinish( pConn ); return HB_FAILURE; } - pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) ); - ( ( SDDCONN * ) pConnection->pSDDConn )->pConn = pConn; + pConnection->pSDDConn = hb_xgrab( sizeof( SDDCONN ) ); + ( ( SDDCONN * ) pConnection->pSDDConn )->pConn = pConn; return HB_SUCCESS; } @@ -205,21 +205,21 @@ static HB_ERRCODE pgsqlExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) unsigned long ulAffectedRows; pResult = PQexec( pConn, hb_itemGetCPtr( pItem ) ); - if ( ! pResult ) + if( ! pResult ) { hb_rddsqlSetError( 1, PQerrorMessage( pConn ), hb_itemGetCPtr( pItem ), NULL, 0 ); return HB_FAILURE; } status = PQresultStatus( pResult ); - if ( status != PGRES_TUPLES_OK && status != PGRES_COMMAND_OK ) + if( status != PGRES_TUPLES_OK && status != PGRES_COMMAND_OK ) { hb_rddsqlSetError( status, PQresultErrorMessage( pResult ), hb_itemGetCPtr( pItem ), NULL, 0 ); return HB_FAILURE; } iTuples = PQntuples( pResult ); - if ( iTuples > 0 ) + if( iTuples > 0 ) ulAffectedRows = ( unsigned long ) iTuples; else ulAffectedRows = ( unsigned long ) atol( PQcmdTuples( pResult ) ); @@ -232,27 +232,27 @@ static HB_ERRCODE pgsqlExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) static HB_ERRCODE pgsqlOpen( SQLBASEAREAP pArea ) { - PGconn * pConn = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pConn; - SDDDATA * pSDDData; - PGresult * pResult; - ExecStatusType status; - PHB_ITEM pItemEof, pItem; - HB_USHORT uiFields, uiCount; - HB_BOOL bError; - DBFIELDINFO pFieldInfo; + PGconn * pConn = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pConn; + SDDDATA * pSDDData; + PGresult * pResult; + ExecStatusType status; + PHB_ITEM pItemEof, pItem; + HB_USHORT uiFields, uiCount; + HB_BOOL bError; + DBFIELDINFO pFieldInfo; - pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); - pSDDData = ( SDDDATA * ) pArea->pSDDData; + pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); + pSDDData = ( SDDDATA * ) pArea->pSDDData; - pResult = PQexec( pConn, pArea->szQuery ); - if ( ! pResult ) + pResult = PQexec( pConn, pArea->szQuery ); + if( ! pResult ) { hb_errRT_PostgreSQLDD( EG_OPEN, ESQLDD_LOWMEMORY, "Query failed", NULL, 0 ); /* Low memory, etc */ return HB_FAILURE; } status = PQresultStatus( pResult ); - if ( status != PGRES_TUPLES_OK && status != PGRES_COMMAND_OK ) + if( status != PGRES_TUPLES_OK && status != PGRES_COMMAND_OK ) { hb_errRT_PostgreSQLDD( EG_OPEN, ESQLDD_INVALIDQUERY, PQresultErrorMessage( pResult ), pArea->szQuery, ( HB_ERRCODE ) status ); PQclear( pResult ); @@ -261,141 +261,141 @@ static HB_ERRCODE pgsqlOpen( SQLBASEAREAP pArea ) pSDDData->pResult = pResult; - uiFields = ( HB_USHORT ) PQnfields( pResult ); + uiFields = ( HB_USHORT ) PQnfields( pResult ); SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields ); - pItemEof = hb_itemArrayNew( uiFields ); - pItem = hb_itemNew( NULL ); + pItemEof = hb_itemArrayNew( uiFields ); + pItem = hb_itemNew( NULL ); - bError = HB_FALSE; - for ( uiCount = 0; uiCount < uiFields; uiCount++ ) + bError = HB_FALSE; + for( uiCount = 0; uiCount < uiFields; uiCount++ ) { - pFieldInfo.atomName = PQfname( pResult, ( int ) uiCount ); - pFieldInfo.uiDec = 0; + pFieldInfo.atomName = PQfname( pResult, ( int ) uiCount ); + pFieldInfo.uiDec = 0; switch( PQftype( pResult, ( int ) uiCount ) ) { case BPCHAROID: case VARCHAROID: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = ( HB_USHORT ) PQfmod( pResult, uiCount ) - 4; + pFieldInfo.uiLen = ( HB_USHORT ) PQfmod( pResult, uiCount ) - 4; break; case TEXTOID: pFieldInfo.uiType = HB_FT_MEMO; - pFieldInfo.uiLen = 10; + pFieldInfo.uiLen = 10; break; case NUMERICOID: pFieldInfo.uiType = HB_FT_DOUBLE; - pFieldInfo.uiLen = ( PQfmod( pResult, uiCount ) - 4 ) >> 16; - pFieldInfo.uiDec = ( PQfmod( pResult, uiCount ) - 4 ) & 0xFFFF; + pFieldInfo.uiLen = ( PQfmod( pResult, uiCount ) - 4 ) >> 16; + pFieldInfo.uiDec = ( PQfmod( pResult, uiCount ) - 4 ) & 0xFFFF; break; case INT2OID: pFieldInfo.uiType = HB_FT_INTEGER; - pFieldInfo.uiLen = 6; + pFieldInfo.uiLen = 6; break; case INT4OID: pFieldInfo.uiType = HB_FT_INTEGER; - pFieldInfo.uiLen = 11; + pFieldInfo.uiLen = 11; break; case INT8OID: case OIDOID: pFieldInfo.uiType = HB_FT_LONG; - pFieldInfo.uiLen = 20; + pFieldInfo.uiLen = 20; break; case FLOAT4OID: case FLOAT8OID: case CASHOID: /* TODO: ??? */ pFieldInfo.uiType = HB_FT_DOUBLE; - pFieldInfo.uiLen = 16; - pFieldInfo.uiDec = 2; /* TODO: hb_set.SET_DECIMALS ??? */ + pFieldInfo.uiLen = 16; + pFieldInfo.uiDec = 2; /* TODO: hb_set.SET_DECIMALS ??? */ break; case BOOLOID: pFieldInfo.uiType = HB_FT_LOGICAL; - pFieldInfo.uiLen = 1; + pFieldInfo.uiLen = 1; break; case DATEOID: pFieldInfo.uiType = HB_FT_DATE; - pFieldInfo.uiLen = 8; + pFieldInfo.uiLen = 8; break; case INETOID: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = 29; + pFieldInfo.uiLen = 29; break; case CIDROID: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = 32; + pFieldInfo.uiLen = 32; break; case MACADDROID: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = 17; + pFieldInfo.uiLen = 17; break; case BITOID: case VARBITOID: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = ( HB_USHORT ) PQfsize( pResult, uiCount ); + pFieldInfo.uiLen = ( HB_USHORT ) PQfsize( pResult, uiCount ); break; case TIMEOID: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = 12; + pFieldInfo.uiLen = 12; break; case TIMESTAMPOID: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = 23; + pFieldInfo.uiLen = 23; break; case TIMETZOID: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = 15; + pFieldInfo.uiLen = 15; break; case TIMESTAMPTZOID: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = 26; + pFieldInfo.uiLen = 26; break; case NAMEOID: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = 63; + pFieldInfo.uiLen = 63; break; case BYTEAOID: pFieldInfo.uiType = HB_FT_STRING; - pFieldInfo.uiLen = 0; + pFieldInfo.uiLen = 0; break; default: pFieldInfo.uiType = 0; - pFieldInfo.uiLen = 0; - bError = HB_TRUE; + pFieldInfo.uiLen = 0; + bError = HB_TRUE; break; } /* printf( "field:%s \ttype:%d \tsize:%d \tformat:%d \tmod:%d err=%d\n", pFieldInfo.atomName, PQftype( pResult, ( int ) uiCount ), PQfsize( pResult, uiCount ), PQfformat( pResult, uiCount ) , PQfmod( pResult, uiCount ), bError ); */ - if ( ! bError ) + if( ! bError ) { - switch ( pFieldInfo.uiType ) + switch( pFieldInfo.uiType ) { case HB_FT_STRING: { - char* pStr; + char * pStr; - pStr = ( char * ) hb_xgrab( pFieldInfo.uiLen + 1 ); + pStr = ( char * ) hb_xgrab( pFieldInfo.uiLen + 1 ); memset( pStr, ' ', pFieldInfo.uiLen ); - pStr[ pFieldInfo.uiLen ] = '\0'; + pStr[ pFieldInfo.uiLen ] = '\0'; hb_itemPutCL( pItem, pStr, pFieldInfo.uiLen ); hb_xfree( pStr ); @@ -439,33 +439,33 @@ static HB_ERRCODE pgsqlOpen( SQLBASEAREAP pArea ) pFieldInfo.uiType = HB_IT_LONG; } */ - if ( ! bError ) + if( ! bError ) bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE ); } - if ( bError ) + if( bError ) break; } hb_itemRelease( pItem ); - if ( bError ) + if( bError ) { - hb_itemClear( pItemEof ); - hb_itemRelease( pItemEof ); - hb_errRT_PostgreSQLDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, 0 ); - return HB_FAILURE; + hb_itemClear( pItemEof ); + hb_itemRelease( pItemEof ); + hb_errRT_PostgreSQLDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, 0 ); + return HB_FAILURE; } - pArea->ulRecCount = ( HB_ULONG ) PQntuples( pResult ); + pArea->ulRecCount = ( HB_ULONG ) PQntuples( pResult ); - pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) ); - pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) ); + pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) ); + pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) ); memset( pArea->pRowFlags, 0, ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) ); - * pArea->pRow = pItemEof; - pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; - pArea->fFetched = HB_TRUE; + *pArea->pRow = pItemEof; + pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; + pArea->fFetched = HB_TRUE; return HB_SUCCESS; } @@ -477,7 +477,7 @@ static HB_ERRCODE pgsqlClose( SQLBASEAREAP pArea ) if( pSDDData ) { - if ( pSDDData->pResult ) + if( pSDDData->pResult ) PQclear( pSDDData->pResult ); hb_xfree( pSDDData ); @@ -489,22 +489,22 @@ static HB_ERRCODE pgsqlClose( SQLBASEAREAP pArea ) static HB_ERRCODE pgsqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem ) { - SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData; - LPFIELD pField; - char* pValue; - HB_BOOL bError; - PHB_ITEM pError; - HB_SIZE ulLen; + SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData; + LPFIELD pField; + char * pValue; + HB_BOOL bError; + PHB_ITEM pError; + HB_SIZE ulLen; - bError = HB_FALSE; + bError = HB_FALSE; uiIndex--; - pField = pArea->area.lpFields + uiIndex; + pField = pArea->area.lpFields + uiIndex; - if ( PQgetisnull( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex ) ) + if( PQgetisnull( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex ) ) return HB_SUCCESS; - pValue = PQgetvalue( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex ); - ulLen = ( HB_SIZE ) PQgetlength( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex ); + pValue = PQgetvalue( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex ); + ulLen = ( HB_SIZE ) PQgetlength( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex ); /* printf( "fieldget recno:%d index:%d value:%s len:%d\n", pArea->ulRecNo, uiIndex, pValue, ulLen ); */ @@ -522,16 +522,16 @@ static HB_ERRCODE pgsqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM case HB_FT_INTEGER: case HB_FT_LONG: case HB_FT_DOUBLE: - if ( pField->uiDec ) + if( pField->uiDec ) hb_itemPutNDLen( pItem, atof( pValue ), ( int ) pField->uiLen - ( ( int ) pField->uiDec + 1 ), ( int ) pField->uiDec ); else - if ( pField->uiLen > 9 ) - hb_itemPutNDLen( pItem, atof( pValue ), - ( int ) pField->uiLen, ( int ) pField->uiDec ); - else - hb_itemPutNLLen( pItem, atol( pValue ), ( int ) pField->uiLen ); + if( pField->uiLen > 9 ) + hb_itemPutNDLen( pItem, atof( pValue ), + ( int ) pField->uiLen, ( int ) pField->uiDec ); + else + hb_itemPutNLLen( pItem, atol( pValue ), ( int ) pField->uiLen ); break; case HB_FT_LOGICAL: @@ -541,7 +541,7 @@ static HB_ERRCODE pgsqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM case HB_FT_DATE: { - char szDate[ 9 ]; + char szDate[ 9 ]; szDate[ 0 ] = pValue[ 0 ]; szDate[ 1 ] = pValue[ 1 ]; @@ -561,7 +561,7 @@ static HB_ERRCODE pgsqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM break; } - if ( bError ) + if( bError ) { pError = hb_errNew(); hb_errPutGenCode( pError, EG_DATATYPE ); diff --git a/harbour/examples/hbapollo/append.c b/harbour/examples/hbapollo/append.c index 07a3223f54..e2f3b4d10d 100644 --- a/harbour/examples/hbapollo/append.c +++ b/harbour/examples/hbapollo/append.c @@ -26,12 +26,12 @@ static int _checkDelim( int _nDelim ); static int _checkDelimChar( const char * _cDelim ); -static const char * aDelim[] = +static const char * s_aDelim[] = { "SDENTX", "SDEFOX", "SDENSX", "SDENSX_DBT", "COMMA_DELIM", "SDF_FILE", "TAB_DELIM", "OEMNTX", "OEMFOX", "OEMNSX" }; -static int nDelim[] = { 1, 2, 3, 4, 21, 22, 23, 31, 32, 33 }; +static int s_nDelim[] = { 1, 2, 3, 4, 21, 22, 23, 31, 32, 33 }; /* 2003.05.08 added parameter for work area to work on */ HB_FUNC( SX_APPEND ) @@ -219,8 +219,8 @@ static int _checkDelim( int _nDelim ) for( ui = 0; ui < 10; ui++ ) { - if( _nDelim == nDelim[ ui ] ) - return nDelim[ ui ]; + if( _nDelim == s_nDelim[ ui ] ) + return s_nDelim[ ui ]; } return -1; @@ -238,9 +238,9 @@ static int _checkDelimChar( const char * _cDelim ) for( ui = 0; ui < 10; ui++ ) { - if( strcmp( szTmp, aDelim[ ui ] ) == 0 ) + if( strcmp( szTmp, s_aDelim[ ui ] ) == 0 ) { - iResult = nDelim[ ui ]; + iResult = s_nDelim[ ui ]; break; } } diff --git a/harbour/examples/hbapollo/dbdelim.c b/harbour/examples/hbapollo/dbdelim.c index 9747376054..696a5104b3 100644 --- a/harbour/examples/hbapollo/dbdelim.c +++ b/harbour/examples/hbapollo/dbdelim.c @@ -24,7 +24,7 @@ */ #include "sxapi.h" -static HB_BOOL bSDF = HB_FALSE; +static HB_BOOL s_bSDF = HB_FALSE; static void _sx_GetLine( PHB_ITEM pArray, FILE * hFileHandle, char * cDelimiter ) { @@ -46,7 +46,7 @@ static void _sx_GetLine( PHB_ITEM pArray, FILE * hFileHandle, char * cDelimiter if( ! ( strcmp( cFieldType, "M" ) == 0 ) ) { cTemp = ( char * ) sx_GetVariant( ( PBYTE ) cFieldName ); - if( ! bSDF ) + if( ! s_bSDF ) cTemp = _sx_rtrim( cTemp ); else { @@ -76,7 +76,7 @@ static void _sx_GetLine( PHB_ITEM pArray, FILE * hFileHandle, char * cDelimiter if( ! ( strcmp( cFieldType, "M" ) == 0 ) ) { cTemp = ( char * ) sx_GetVariant( ( PBYTE ) cFieldName ); - if( ! bSDF ) + if( ! s_bSDF ) cTemp = _sx_rtrim( cTemp ); else { @@ -140,9 +140,9 @@ HB_FUNC( __SX_DBDELIM ) /* (file, delim, afields, bfor, bwhile, nnext, nrec, l cDelimiter = " "; if( strcmp( cDelimiter, "SDF" ) == 0 ) - bSDF = HB_TRUE; + s_bSDF = HB_TRUE; else - bSDF = HB_FALSE; + s_bSDF = HB_FALSE; /* CodeBlock passed ? */ if( ! HB_ISNIL( 4 ) && ! HB_ISBLOCK( 4 ) ) diff --git a/harbour/examples/hbapollo/global.c b/harbour/examples/hbapollo/global.c index 0a11a7c9e7..e81960cbef 100644 --- a/harbour/examples/hbapollo/global.c +++ b/harbour/examples/hbapollo/global.c @@ -25,19 +25,19 @@ #include "sxapi.h" /* Modified To return .T. if Century is set ON or .F. is Century is set OFF. */ -static HB_BOOL bCenturyIsOn = HB_FALSE; -static char * aFormat[] = +static HB_BOOL s_bCenturyIsOn = HB_FALSE; +static char * s_aFormat[] = { "AMERICAN", "ANSI", "BRITISH", "FRENCH", "GERMAN", "ITALIAN", "SPANISH", "MM/DD/YY", "YY.MM.DD", "DD/MM/YY", "DD/MM/YY", "DD.MM.YY", "DD-MM-YY", "DD-MM-YY", "MM/DD/YYYY", "YYYY.MM.DD", "DD/MM/YYYY", "DD/MM/YYYY", "DD.MM.YYYY", "DD-MM-YYYY", "DD-MM-YYYY" }; -static HB_BOOL lDeletedIsOn = HB_FALSE; -static int iBaseYear = 0; -static HB_BOOL bSetExactIsOn = HB_FALSE; -static HB_BOOL lSoftSeekIsOn; -static const char * sxApiRDD[] = +static HB_BOOL s_lDeletedIsOn = HB_FALSE; +static int s_iBaseYear = 0; +static HB_BOOL s_bSetExactIsOn = HB_FALSE; +static HB_BOOL s_lSoftSeekIsOn; +static const char * s_sxApiRDD[] = { "SDENTX", "SDEFOX", "SDENSX", "SDENSXDBT", "DBFNTX", "DBFIDX", "DBFNSX", "DBFNSXDBT" @@ -67,12 +67,12 @@ HB_FUNC( SX_SETSOFTSEEK ) PHB_ITEM pItem; WORD wSoftSeek = 0; - lSoftSeekIsOn = hb_setGetSoftSeek(); + s_lSoftSeekIsOn = hb_setGetSoftSeek(); - hb_retl( lSoftSeekIsOn ); + hb_retl( s_lSoftSeekIsOn ); if( HB_ISLOG( 1 ) ) - lSoftSeekIsOn = hb_parl( 1 ); + s_lSoftSeekIsOn = hb_parl( 1 ); else if( HB_ISCHAR( 1 ) ) { HB_ISIZ iLen = hb_parclen( 1 ) + 1; @@ -80,15 +80,15 @@ HB_FUNC( SX_SETSOFTSEEK ) hb_snprintf( szTmp, iLen, "%s", hb_parc( 1 ) ); - lSoftSeekIsOn = ( strcmp( _sx_upper( szTmp ), "ON" ) == 0 ) ? HB_TRUE : HB_FALSE; + s_lSoftSeekIsOn = ( strcmp( _sx_upper( szTmp ), "ON" ) == 0 ) ? HB_TRUE : HB_FALSE; - if( lSoftSeekIsOn ) + if( s_lSoftSeekIsOn ) wSoftSeek = 1; hb_xfree( szTmp ); } - pItem = hb_itemPutL( NULL, lSoftSeekIsOn ); + pItem = hb_itemPutL( NULL, s_lSoftSeekIsOn ); hb_setSetItem( HB_SET_SOFTSEEK, pItem ); hb_itemRelease( pItem ); @@ -121,12 +121,12 @@ HB_FUNC( SX_SETEXACT ) PHB_ITEM pItem; WORD wSetExact = 0; - bSetExactIsOn = hb_setGetExact(); + s_bSetExactIsOn = hb_setGetExact(); - hb_retl( bSetExactIsOn ); + hb_retl( s_bSetExactIsOn ); if( HB_ISLOG( 1 ) ) - bSetExactIsOn = hb_parl( 1 ); + s_bSetExactIsOn = hb_parl( 1 ); else if( HB_ISCHAR( 1 ) ) { HB_ISIZ iLen = hb_parclen( 1 ) + 1; @@ -134,9 +134,9 @@ HB_FUNC( SX_SETEXACT ) hb_snprintf( szTmp, iLen, "%s", hb_parc( 1 ) ); - bSetExactIsOn = ( strcmp( _sx_upper( szTmp ), "ON" ) == 0 ) ? HB_TRUE : HB_FALSE; + s_bSetExactIsOn = ( strcmp( _sx_upper( szTmp ), "ON" ) == 0 ) ? HB_TRUE : HB_FALSE; - if( bSetExactIsOn ) + if( s_bSetExactIsOn ) wSetExact = 1; hb_xfree( szTmp ); @@ -144,7 +144,7 @@ HB_FUNC( SX_SETEXACT ) sx_SetExact( wSetExact ); - pItem = hb_itemPutL( NULL, bSetExactIsOn ); + pItem = hb_itemPutL( NULL, s_bSetExactIsOn ); hb_setSetItem( HB_SET_EXACT, pItem ); hb_itemRelease( pItem ); @@ -176,18 +176,19 @@ HB_FUNC( SX_SETEPOCH ) WORD iEpoch; PHB_ITEM pItem; - iBaseYear = hb_setGetEpoch(); + s_iBaseYear = hb_setGetEpoch(); - hb_retni( iBaseYear ); + hb_retni( s_iBaseYear ); if( HB_ISNUM( 1 ) ) { - iEpoch = ( WORD ) hb_parni( 1 ); + iEpoch = ( WORD ) hb_parni( 1 ); if( iEpoch == 0 ) hb_errRT_BASE( EG_ARG, 2020, NULL, "SX_SETEPOCH", 1, hb_paramError( 1 ) ); - iBaseYear = iEpoch; - pItem = hb_itemPutNI( NULL, iEpoch ); + s_iBaseYear = iEpoch; + + pItem = hb_itemPutNI( NULL, iEpoch ); hb_setSetItem( HB_SET_EPOCH, pItem ); hb_itemRelease( pItem ); @@ -218,12 +219,12 @@ HB_FUNC( SX_SETDELETED ) PHB_ITEM pItem; WORD wDeleted = 0; - lDeletedIsOn = hb_setGetDeleted(); + s_lDeletedIsOn = hb_setGetDeleted(); - hb_retl( lDeletedIsOn ); + hb_retl( s_lDeletedIsOn ); if( HB_ISLOG( 1 ) ) - lDeletedIsOn = hb_parl( 1 ); + s_lDeletedIsOn = hb_parl( 1 ); else if( HB_ISCHAR( 1 ) ) { HB_ISIZ iLen = hb_parclen( 1 ) + 1; @@ -231,15 +232,15 @@ HB_FUNC( SX_SETDELETED ) hb_snprintf( szTmp, iLen, "%s", hb_parc( 1 ) ); - lDeletedIsOn = ( strcmp( _sx_upper( szTmp ), "ON" ) == 0 ) ? HB_TRUE : HB_FALSE; + s_lDeletedIsOn = ( strcmp( _sx_upper( szTmp ), "ON" ) == 0 ) ? HB_TRUE : HB_FALSE; - if( lDeletedIsOn ) + if( s_lDeletedIsOn ) wDeleted = 1; hb_xfree( szTmp ); } - pItem = hb_itemPutL( NULL, lDeletedIsOn ); + pItem = hb_itemPutL( NULL, s_lDeletedIsOn ); hb_setSetItem( HB_SET_DELETED, pItem ); hb_itemRelease( pItem ); @@ -267,7 +268,7 @@ static int _sx_CheckFormat( char * cFormat ) for( i = 0; i < 20; i++ ) { - if( strcmp( aFormat[ i ], cFormat ) == 0 ) + if( strcmp( s_aFormat[ i ], cFormat ) == 0 ) return i; } @@ -367,19 +368,19 @@ HB_FUNC( SX_SETDATEFORMAT ) if( iChecked < 7 ) { if( _sx_SetCentury() ) - szDateFormat = aFormat[ iChecked + 14 ]; + szDateFormat = s_aFormat[ iChecked + 14 ]; else - szDateFormat = aFormat[ iChecked + 7 ]; + szDateFormat = s_aFormat[ iChecked + 7 ]; } else - szDateFormat = aFormat[ iChecked ]; + szDateFormat = s_aFormat[ iChecked ]; __hb_setDateFormat( szDateFormat ); } HB_BOOL _sx_SetCentury() { - return bCenturyIsOn; + return s_bCenturyIsOn; } /* @@ -399,10 +400,10 @@ HB_FUNC( SX_SETCENTURY ) { WORD wCentury = 0; - hb_retl( bCenturyIsOn ); + hb_retl( s_bCenturyIsOn ); if( HB_ISLOG( 1 ) ) - bCenturyIsOn = hb_parl( 1 ); + s_bCenturyIsOn = hb_parl( 1 ); else if( HB_ISCHAR( 1 ) ) { HB_ISIZ iLen = hb_parclen( 1 ) + 1; @@ -410,9 +411,9 @@ HB_FUNC( SX_SETCENTURY ) hb_snprintf( szTmp, iLen, "%s", hb_parc( 1 ) ); - bCenturyIsOn = ( strcmp( _sx_upper( szTmp ), "ON" ) == 0 ) ? HB_TRUE : HB_FALSE; + s_bCenturyIsOn = ( strcmp( _sx_upper( szTmp ), "ON" ) == 0 ) ? HB_TRUE : HB_FALSE; - if( bCenturyIsOn ) + if( s_bCenturyIsOn ) wCentury = 1; hb_xfree( szTmp ); @@ -771,7 +772,7 @@ HB_FUNC( SX_RDDSETDEFAULT ) { int ui; - hb_retc( ( char * ) sxApiRDD[ i_sxApi_RDD_Default - 1 ] ); + hb_retc( ( char * ) s_sxApiRDD[ i_sxApi_RDD_Default - 1 ] ); if( HB_ISCHAR( 1 ) ) { @@ -799,7 +800,7 @@ int _sx_CheckRDD( const char * sSetDefault ) #endif for( ui = 0; ui < 8; ui++ ) { - if( strcmp( sxApiRDD[ ui ], sSetDefault /* szTmp */ ) == 0 ) + if( strcmp( s_sxApiRDD[ ui ], sSetDefault /* szTmp */ ) == 0 ) { bCorrect = HB_TRUE; break; diff --git a/harbour/examples/hbapollo/sde.c b/harbour/examples/hbapollo/sde.c index 6b3176a072..c649c85db6 100644 --- a/harbour/examples/hbapollo/sde.c +++ b/harbour/examples/hbapollo/sde.c @@ -26,16 +26,6 @@ #define __SXAPI_INIT #include "sxapi.h" -#ifdef __cplusplus -extern "C" { -#endif - -extern PHB_ITEM Opened_DBF_Property; - -#ifdef __cplusplus -} -#endif - static void __sx_CreateINITFile( const char * pIniFile ) { FILE * FIniHandle = hb_fopen( pIniFile, "w" ); diff --git a/harbour/examples/hbapollo/sxapi.h b/harbour/examples/hbapollo/sxapi.h index dc4c774a45..4f0794e2a0 100644 --- a/harbour/examples/hbapollo/sxapi.h +++ b/harbour/examples/hbapollo/sxapi.h @@ -53,10 +53,6 @@ #include "sde7.h" #endif -#ifdef __cplusplus -extern "C" { -#endif - /* ******************************************************* */ /* SDE defines */ /* ******************************************************* */ @@ -289,6 +285,8 @@ typedef struct SX_DBOPENINFO PHB_ITEM aFieldInfo; } SX_DBOPENINFO; +HB_EXTERN_BEGIN + extern LONG _sx_SysProp( WORD uiSysItem, PVOID vpData ); extern char * _sx_randomname( const char * szPrefix ); extern PHB_ITEM _sx_FieldNames( void ); @@ -320,7 +318,7 @@ extern PHB_ITEM _sx_GetAlias( void ); int i_sxApi_MemoBlock_Size; /* Default Memo Block Size */ int i_sxApi_Error_Level; /* Default ErrorLevel */ int i_sxApi_RDD_Default; /* Default RDD Driver */ - HB_BOOL bSetTrimmedON = HB_FALSE; + HB_BOOL bSetTrimmedON = HB_FALSE; PHB_ITEM Opened_DBF_Property = NULL; #else extern int i_sxApi_MemoBlock_Size; /* Default Memo Block Size */ @@ -330,6 +328,8 @@ extern PHB_ITEM _sx_GetAlias( void ); extern PHB_ITEM Opened_DBF_Property; #endif +HB_EXTERN_END + #define AMERICAN 0 /* MM/DD/YY */ #define ANSI 1 /* YY.MM.DD */ #define BRITISH 2 /* DD/MM/YY */ @@ -338,8 +338,4 @@ extern PHB_ITEM _sx_GetAlias( void ); #define ITALIAN 5 /* DD-MM-YY */ #define SPANISH 6 /* DD-MM-YY */ -#ifdef __cplusplus -} -#endif - #endif diff --git a/harbour/examples/hbapollo/tools.c b/harbour/examples/hbapollo/tools.c index 8c9c383c2a..104ddd7fe5 100644 --- a/harbour/examples/hbapollo/tools.c +++ b/harbour/examples/hbapollo/tools.c @@ -27,22 +27,23 @@ const char * _sx_CheckFileExt( const char * szFileName ) { - PHB_FNAME pFileName = hb_fsFNameSplit( szFileName ); - static char _szFileName[ HB_PATH_MAX ]; + static char s_szFileName[ HB_PATH_MAX ]; /* TOFIX */ - memset( _szFileName, 0, HB_PATH_MAX ); + PHB_FNAME pFileName = hb_fsFNameSplit( szFileName ); + + memset( s_szFileName, 0, HB_PATH_MAX ); if( ! pFileName->szExtension ) { pFileName->szExtension = ".dbf"; - hb_fsFNameMerge( _szFileName, pFileName ); + hb_fsFNameMerge( s_szFileName, pFileName ); } else - hb_xstrcpy( _szFileName, szFileName, 0 ); + hb_xstrcpy( s_szFileName, szFileName, 0 ); hb_xfree( pFileName ); - return _szFileName; + return s_szFileName; } double sx_GetPrivateProfileDouble( LPSTR lpSectionName, LPSTR lpEntryName, @@ -91,15 +92,12 @@ PHB_ITEM _sx_GetAlias( void ) { PHB_ITEM pResult; -#ifdef __cplusplus - static PHB_DYNS -#else - static PHB_DYNS pFunc = NULL; - if( ! pFunc ) -#endif - pFunc = hb_dynsymFind( "CALIAS" ); + static PHB_DYNS s_pFunc = NULL; - hb_objProcessMessage( hb_stackSelfItem(), pFunc, 0 ); + if( ! s_pFunc ) + s_pFunc = hb_dynsymFind( "CALIAS" ); + + hb_objProcessMessage( hb_stackSelfItem(), s_pFunc, 0 ); pResult = hb_itemNew( NULL ); hb_itemCopy( pResult, hb_stackReturnItem() ); return pResult; diff --git a/harbour/examples/hbapollo/use.c b/harbour/examples/hbapollo/use.c index bd8abda15e..1eeac61bcd 100644 --- a/harbour/examples/hbapollo/use.c +++ b/harbour/examples/hbapollo/use.c @@ -24,11 +24,11 @@ */ #include "sxapi.h" -static const char * cRDD[] = { "SDENTX", "SDEFOX", "SDENSX", "SDENSX_DBT" }; -static const char * aDescription[] = +static const char * s_cRDD[] = { "SDENTX", "SDEFOX", "SDENSX", "SDENSX_DBT" }; +static const char * s_aDescription[] = { "WORKAREA (INTEGER)", "FILENAME (STRING)", "ALIAS (STRING)", - "SHARED (HB_BOOL)", "READONLY (HB_BOOL)", "RDE TYTE (INTEGER)", + "SHARED (BOOL)", "READONLY (BOOL)", "RDE TYTE (INTEGER)", "OPEN MODE (INTEGER)", "RDE TYPE (STRING)", "COMMIT LEVEL (INTEGER)", "RECSIZE (INTEGER)", "FIELD COUNT (INTEGER)", "DBF STRUCTURE (ARRAY)" }; @@ -66,11 +66,11 @@ void _sx_SetDBFInfo( int iOpenedArea, const char * szAlias, int iOpenMode, OpenInfo.uiArea = ( HB_USHORT ) iOpenedArea; OpenInfo.cFilename = ( char * ) sx_BaseName(); OpenInfo.cAlias = szAlias; - OpenInfo.fShared = ( ( iOpenMode == 0 ) ? HB_TRUE : HB_FALSE ); - OpenInfo.fReadonly = ( ( iOpenMode == READONLY ) ? HB_TRUE : HB_FALSE ); + OpenInfo.fShared = ( ( iOpenMode == 0 ) ? TRUE : FALSE ); + OpenInfo.fReadonly = ( ( iOpenMode == READONLY ) ? TRUE : FALSE ); OpenInfo.iRDEType = ( HB_USHORT ) iRDEType; OpenInfo.iMode = ( HB_USHORT ) iOpenMode; - OpenInfo.cRDD = cRDD[ iRDEType - 1 ]; + OpenInfo.cRDD = s_cRDD[ iRDEType - 1 ]; OpenInfo.iCommitLevel = ( HB_USHORT ) sx_GetCommitLevel( ( WORD ) iOpenedArea ); OpenInfo.iRecSize = ( HB_USHORT ) sx_RecSize(); OpenInfo.iFieldCount = sx_FieldCount(); @@ -222,14 +222,14 @@ HB_FUNC( SX_DBINFO ) if( hb_arrayGetType( aDesc, j + 1 ) & HB_IT_STRING ) { char * szStr = hb_arrayGetC( aDesc, j + 1 ); - hb_snprintf( szDesc, 255, "%s=%s", aDescription[ j ], szStr ); + hb_snprintf( szDesc, 255, "%s=%s", s_aDescription[ j ], szStr ); hb_xfree( szStr ); } else if( hb_arrayGetType( aDesc, j + 1 ) & HB_IT_NUMERIC ) - hb_snprintf( szDesc, 255, "%s=%i", aDescription[ j ], + hb_snprintf( szDesc, 255, "%s=%i", s_aDescription[ j ], hb_arrayGetNI( aDesc, j + 1 ) ); else if( hb_arrayGetType( aDesc, j + 1 ) & HB_IT_LOGICAL ) - hb_snprintf( szDesc, 255, "%s=%s", aDescription[ j ], + hb_snprintf( szDesc, 255, "%s=%s", s_aDescription[ j ], hb_arrayGetL( aDesc, j + 1 ) ? ".T." : ".F." ); else if( hb_arrayGetType( aDesc, j + 1 ) & HB_IT_ARRAY ) {