| dbcmd.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | AFIELDS(void)
HB_FUNC( AFIELDS )
{
USHORT uiFields, uiCount;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
PHB_ITEM pName = hb_param( 1, HB_IT_ARRAY );
PHB_ITEM pType = hb_param( 2, HB_IT_ARRAY );
PHB_ITEM pLen = hb_param( 3, HB_IT_ARRAY );
PHB_ITEM pDec = hb_param( 4, HB_IT_ARRAY );
#ifdef DBS_FLAG
PHB_ITEM pFlags = hb_param( 5, HB_IT_ARRAY );
#else
PHB_ITEM pFlags = NULL;
#endif
if( !pArea || ( !pName && !pType && !pLen && !pDec && !pFlags ) )
{
hb_retni( 0 );
return;
}
if( SELF_FIELDCOUNT( pArea, &uiFields ) != SUCCESS )
return;
if( pName )
{
USHORT uiArrayLen = ( USHORT ) hb_arrayLen( pName );
if( uiArrayLen < uiFields )
uiFields = uiArrayLen;
}
if( pType )
{
USHORT uiArrayLen = ( USHORT ) hb_arrayLen( pType );
if( uiArrayLen < uiFields )
uiFields = uiArrayLen;
}
if( pLen )
{
USHORT uiArrayLen = ( USHORT ) hb_arrayLen( pLen );
if( uiArrayLen < uiFields )
uiFields = uiArrayLen;
}
if( pDec )
{
USHORT uiArrayLen = ( USHORT ) hb_arrayLen( pDec );
if( uiArrayLen < uiFields )
uiFields = uiArrayLen;
}
if( pFlags )
{
USHORT uiArrayLen = ( USHORT ) hb_arrayLen( pFlags );
if( uiArrayLen < uiFields )
uiFields = uiArrayLen;
}
if( pName )
{
for( uiCount = 1; uiCount <= uiFields; ++uiCount )
{
if( SELF_FIELDINFO( pArea, uiCount, DBS_NAME, hb_arrayGetItemPtr( pName, uiCount ) ) != SUCCESS )
return;
}
}
if( pType )
{
for( uiCount = 1; uiCount <= uiFields; ++uiCount )
{
if( SELF_FIELDINFO( pArea, uiCount, DBS_TYPE, hb_arrayGetItemPtr( pType, uiCount ) ) != SUCCESS )
return;
}
}
if( pLen )
{
for( uiCount = 1; uiCount <= uiFields; ++uiCount )
{
if( SELF_FIELDINFO( pArea, uiCount, DBS_LEN, hb_arrayGetItemPtr( pLen, uiCount ) ) != SUCCESS )
return;
}
}
if( pDec )
{
for( uiCount = 1; uiCount <= uiFields; ++uiCount )
{
if( SELF_FIELDINFO( pArea, uiCount, DBS_DEC, hb_arrayGetItemPtr( pDec, uiCount ) ) != SUCCESS )
return;
}
}
#ifdef DBS_FLAG
if( pFlags )
{
for( uiCount = 1; uiCount <= uiFields; ++uiCount )
{
if( SELF_FIELDINFO( pArea, uiCount, DBS_FLAG, hb_arrayGetItemPtr( pFlags, uiCount ) ) != SUCCESS )
return;
}
}
#endif
hb_retni( uiFields );
}
| dbcmd.c | 71 |
| HB_FUNC | ALIAS(void)
HB_FUNC( ALIAS )
{
int iArea;
AREAP pArea;
iArea = hb_parni( 1 );
pArea = ( AREAP ) hb_rddGetWorkAreaPointer( iArea );
if( pArea )
{
char szAlias[ HB_RDD_MAX_ALIAS_LEN + 1 ];
if( SELF_ALIAS( pArea, ( BYTE * ) szAlias ) == SUCCESS )
{
hb_retc( szAlias );
return;
}
}
hb_retc( NULL );
}
| dbcmd.c | 173 |
| HB_FUNC | DBEVAL(void)
HB_FUNC( DBEVAL )
{
DBEVALINFO pEvalInfo;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
memset( &pEvalInfo, 0, sizeof( DBEVALINFO ) );
pEvalInfo.itmBlock = hb_param( 1, HB_IT_BLOCK );
if( !pEvalInfo.itmBlock )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_EVAL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
pEvalInfo.dbsci.itmCobFor = hb_param( 2, HB_IT_BLOCK );
if( !pEvalInfo.dbsci.itmCobFor && !ISNIL( 2 ) )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_EVAL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
pEvalInfo.dbsci.itmCobWhile = hb_param( 3, HB_IT_BLOCK );
if( !pEvalInfo.dbsci.itmCobWhile && !ISNIL( 3 ) )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_EVAL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
pEvalInfo.dbsci.lNext = hb_param( 4, HB_IT_NUMERIC );
if( !pEvalInfo.dbsci.lNext && !ISNIL( 4 ) )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_EVAL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
pEvalInfo.dbsci.itmRecID = hb_param( 5, HB_IT_NUMERIC );
if( !pEvalInfo.dbsci.itmRecID && !ISNIL( 5 ) )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_EVAL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
pEvalInfo.dbsci.fRest = hb_param( 6, HB_IT_LOGICAL );
if( !pEvalInfo.dbsci.fRest && !ISNIL( 6 ) )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_EVAL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
SELF_DBEVAL( pArea, &pEvalInfo );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 193 |
| HB_FUNC | DBF(void)
HB_FUNC( DBF )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
char szAlias[ HB_RDD_MAX_ALIAS_LEN + 1 ];
if( SELF_ALIAS( pArea, ( BYTE * ) szAlias ) == SUCCESS )
{
hb_retc( szAlias );
return;
}
}
hb_retc( NULL );
}
| dbcmd.c | 249 |
| HB_FUNC | BOF(void)
HB_FUNC( BOF )
{
BOOL bBof = TRUE;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_BOF( pArea, &bBof );
hb_retl( bBof );
}
| dbcmd.c | 266 |
| HB_FUNC | DBAPPEND(void)
HB_FUNC( DBAPPEND )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
BOOL bUnLockAll = ISLOG( 1 ) ? hb_parl( 1 ) : TRUE;
ERRCODE errCode;
/* Clipper clears NETERR flag before APPEND */
hb_rddSetNetErr( FALSE );
errCode = SELF_APPEND( pArea, bUnLockAll );
hb_retl( errCode == SUCCESS );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 277 |
| HB_FUNC | DBCLEARFILTER(void)
HB_FUNC( DBCLEARFILTER )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_CLEARFILTER( pArea );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 295 |
| HB_FUNC | DBCLOSEALL(void)
HB_FUNC( DBCLOSEALL )
{
hb_rddCloseAll();
}
| dbcmd.c | 305 |
| HB_FUNC | DBCLOSEAREA(void)
HB_FUNC( DBCLOSEAREA )
{
hb_rddReleaseCurrentArea();
}
| dbcmd.c | 310 |
| HB_FUNC | DBCOMMIT(void)
HB_FUNC( DBCOMMIT )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_FLUSH( pArea );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 315 |
| HB_FUNC | DBCOMMITALL(void)
HB_FUNC( DBCOMMITALL )
{
hb_rddFlushAll();
}
| dbcmd.c | 324 |
| HB_FUNC | DBCREATE(void)
HB_FUNC( DBCREATE )
{
char * szFileName, * szAlias, * szDriver, * szCpId;
USHORT uiSize, uiLen;
PHB_ITEM pStruct, pFieldDesc, pDelim;
BOOL fKeepOpen, fCurrArea;
ULONG ulConnection;
/*
* NOTE: 4-th, 5-th and 6-th parameters are undocumented Clipper ones
* 4-th is boolean flag indicating if file should stay open
* 5-th is alias - if not given then WA is open without alias
* 6-th is optional DELIMITED value used by some RDDs like DELIM
*/
szFileName = hb_parc( 1 );
pStruct = hb_param( 2, HB_IT_ARRAY );
szDriver = hb_parc( 3 );
fKeepOpen = ISLOG( 4 );
fCurrArea = fKeepOpen && !hb_parl( 4 );
szAlias = hb_parc( 5 );
pDelim = hb_param( 6, HB_IT_ANY );
szCpId = hb_parc( 7 );
ulConnection = hb_parnl( 8 );
/*
* Clipper allows to use empty struct array for RDDs which does not
* support fields, f.e.: DBFBLOB in CL5.3
* In CL5.3 it's also possible to create DBF file without fields.
* if some RDD wants to block it then they should serve it in lower
* level, [druzus]
*/
if( !pStruct ||
#ifdef HB_C52_STRICT
hb_arrayLen( pStruct ) == 0 ||
#endif
!szFileName )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBCMDBADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
uiLen = ( USHORT ) hb_arrayLen( pStruct );
for( uiSize = 1; uiSize <= uiLen; ++uiSize )
{
pFieldDesc = hb_arrayGetItemPtr( pStruct, uiSize );
/* Validate items types of fields */
if( hb_arrayLen( pFieldDesc ) < 4 ||
!( hb_arrayGetType( pFieldDesc, 1 ) & HB_IT_STRING ) ||
!( hb_arrayGetType( pFieldDesc, 2 ) & HB_IT_STRING ) ||
!( hb_arrayGetType( pFieldDesc, 3 ) & HB_IT_NUMERIC ) ||
!( hb_arrayGetType( pFieldDesc, 4 ) & HB_IT_NUMERIC ) )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBCMDBADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
}
hb_retl( hb_rddCreateTable( szFileName, szDriver,
fCurrArea ? hb_rddGetCurrentWorkAreaNumber() : 0,
szAlias, fKeepOpen,
szCpId, ulConnection,
pStruct, pDelim ) == SUCCESS );
}
| dbcmd.c | 329 |
| HB_FUNC | __DBOPENSDF(void)
HB_FUNC( __DBOPENSDF )
{
char * szFileName, * szAlias, * szDriver, * szCpId;
USHORT uiSize, uiLen;
PHB_ITEM pStruct, pFieldDesc, pDelim;
BOOL fKeepOpen, fCurrArea;
ULONG ulConnection;
ERRCODE errCode;
/*
* NOTE: 4-th and 5-th parameters are undocumented Clipper ones
* 4-th is boolean flag indicating if file should stay open and
* 5-th is alias - if not given then WA is open without alias
*/
szFileName = hb_parc( 1 );
pStruct = hb_param( 2, HB_IT_ARRAY );
szDriver = hb_parc( 3 );
fKeepOpen = ISLOG( 4 );
fCurrArea = fKeepOpen && !hb_parl( 4 );
szAlias = hb_parc( 5 );
pDelim = hb_param( 6, HB_IT_ANY );
szCpId = hb_parc( 7 );
ulConnection = hb_parnl( 8 );
if( !pStruct ||
hb_arrayLen( pStruct ) == 0 ||
!szFileName || !szFileName[ 0 ] )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBCMDBADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
uiLen = ( USHORT ) hb_arrayLen( pStruct );
for( uiSize = 1; uiSize <= uiLen; ++uiSize )
{
pFieldDesc = hb_arrayGetItemPtr( pStruct, uiSize );
/* Validate items types of fields */
if( hb_arrayLen( pFieldDesc ) < 4 ||
!( hb_arrayGetType( pFieldDesc, 1 ) & HB_IT_STRING ) ||
!( hb_arrayGetType( pFieldDesc, 2 ) & HB_IT_STRING ) ||
!( hb_arrayGetType( pFieldDesc, 3 ) & HB_IT_NUMERIC ) ||
!( hb_arrayGetType( pFieldDesc, 4 ) & HB_IT_NUMERIC ) )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBCMDBADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
}
errCode = hb_rddOpenTable( szFileName, szDriver,
fCurrArea ? hb_rddGetCurrentWorkAreaNumber() : 0,
szAlias, TRUE, TRUE,
szCpId, ulConnection,
pStruct, pDelim );
if( !fKeepOpen && errCode == SUCCESS )
hb_rddReleaseCurrentArea();
hb_retl( errCode == SUCCESS );
}
| dbcmd.c | 401 |
| HB_FUNC | DBDELETE(void)
HB_FUNC( DBDELETE )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_DELETE( pArea );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 470 |
| HB_FUNC | DBFILTER(void)
HB_FUNC( DBFILTER )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
PHB_ITEM pFilter = hb_itemPutC( NULL, NULL );
SELF_FILTERTEXT( pArea, pFilter );
hb_itemReturnRelease( pFilter );
}
else
hb_retc( NULL );
}
| dbcmd.c | 480 |
| HB_FUNC | DBGOBOTTOM(void)
HB_FUNC( DBGOBOTTOM )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_GOBOTTOM( pArea );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 494 |
| HB_FUNC | DBGOTO(void)
HB_FUNC( DBGOTO )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
if( !pItem )
hb_errRT_DBCMD( EG_ARG, EDBCMD_NOVAR, NULL, HB_ERR_FUNCNAME );
else
SELF_GOTOID( pArea, pItem );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 504 |
| HB_FUNC | DBGOTOP(void)
HB_FUNC( DBGOTOP )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_GOTOP( pArea );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 520 |
| HB_FUNC | __DBLOCATE(void)
HB_FUNC( __DBLOCATE )
{
DBSCOPEINFO dbScopeInfo;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
dbScopeInfo.itmCobFor = hb_param( 1, HB_IT_BLOCK );
dbScopeInfo.lpstrFor = NULL;
dbScopeInfo.itmCobWhile = hb_param( 2, HB_IT_BLOCK );
dbScopeInfo.lpstrWhile = NULL;
dbScopeInfo.lNext = hb_param( 3, HB_IT_NUMERIC );
dbScopeInfo.itmRecID = hb_param( 4, HB_IT_NUMERIC );
dbScopeInfo.fRest = hb_param( 5, HB_IT_LOGICAL );
dbScopeInfo.fIgnoreFilter = TRUE;
dbScopeInfo.fIncludeDeleted = TRUE;
dbScopeInfo.fLast = FALSE;
dbScopeInfo.fIgnoreDuplicates = FALSE;
dbScopeInfo.fBackward = FALSE;
if( SELF_SETLOCATE( pArea, &dbScopeInfo ) == SUCCESS )
SELF_LOCATE( pArea, FALSE );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EG_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 530 |
| HB_FUNC | __DBSETLOCATE(void)
HB_FUNC( __DBSETLOCATE )
{
PHB_ITEM pLocate;
DBSCOPEINFO pScopeInfo;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
pLocate = hb_param( 1, HB_IT_BLOCK );
if( pLocate )
{
memset( &pScopeInfo, 0, sizeof( DBSCOPEINFO ) );
pScopeInfo.itmCobFor = pLocate;
SELF_SETLOCATE( pArea, &pScopeInfo );
}
}
}
| dbcmd.c | 558 |
| HB_FUNC | __DBCONTINUE(void)
HB_FUNC( __DBCONTINUE )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_LOCATE( pArea, TRUE );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 576 |
| HB_FUNC | __DBPACK(void)
HB_FUNC( __DBPACK )
{
PHB_ITEM pBlock, pEvery;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
/*
* Additional feature: __dbPack( [, [] )
* Code Block to execute for every record.
*/
pBlock = hb_param( 1, HB_IT_BLOCK );
if( pBlock )
{
hb_itemRelease( pArea->valResult );
pArea->valResult = hb_itemArrayNew( 2 );
hb_arraySet( pArea->valResult, 1, pBlock );
pEvery = hb_param( 2, HB_IT_ANY );
if( pEvery && HB_IS_NUMERIC( pEvery ) )
hb_arraySet( pArea->valResult, 2, pEvery );
}
else
{
if( pArea->valResult )
hb_itemClear( pArea->valResult );
else
pArea->valResult = hb_itemNew( NULL );
}
SELF_PACK( pArea );
if( pBlock )
hb_itemClear( pArea->valResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 586 |
| HB_FUNC | DBRECALL(void)
HB_FUNC( DBRECALL )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_RECALL( pArea );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 622 |
| HB_FUNC | DBRLOCK(void)
HB_FUNC( DBRLOCK )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBLOCKINFO dbLockInfo;
dbLockInfo.fResult = FALSE;
dbLockInfo.itmRecID = hb_param( 1, HB_IT_ANY );
if( !dbLockInfo.itmRecID || ISNIL( 1 ) )
dbLockInfo.uiMethod = DBLM_EXCLUSIVE;
else
dbLockInfo.uiMethod = DBLM_MULTIPLE;
SELF_LOCK( pArea, &dbLockInfo );
hb_retl( dbLockInfo.fResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 631 |
| HB_FUNC | DBRLOCKLIST(void)
HB_FUNC( DBRLOCKLIST )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
PHB_ITEM pList = hb_itemArrayNew( 0 );
SELF_INFO( pArea, DBI_GETLOCKARRAY, pList );
hb_itemReturnRelease( pList );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 651 |
| HB_FUNC | DBRUNLOCK(void)
HB_FUNC( DBRUNLOCK )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_UNLOCK( pArea, hb_param( 1, HB_IT_ANY ) );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 666 |
| HB_FUNC | DBSEEK(void)
HB_FUNC( DBSEEK )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
if( !ISNIL( 1 ) )
{
PHB_ITEM pKey = hb_param( 1, HB_IT_ANY );
BOOL bSoftSeek = ISLOG( 2 ) ? ( BOOL ) hb_parl( 2 ) : hb_setGetSoftSeek();
BOOL bFindLast = ISLOG( 3 ) ? hb_parl( 3 ) : FALSE, fFound = FALSE;
if( SELF_SEEK( pArea, bSoftSeek, pKey, bFindLast ) == SUCCESS )
{
if( SELF_FOUND( pArea, &fFound ) != SUCCESS )
fFound = FALSE;
}
hb_retl( fFound );
}
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_SEEK_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 676 |
| HB_FUNC | DBSELECTAREA(void)
HB_FUNC( DBSELECTAREA )
{
char * szAlias = hb_parc( 1 );
if( szAlias )
{
hb_rddSelectWorkAreaAlias( szAlias );
if( hb_rddGetCurrentWorkAreaNumber() == HB_RDD_MAX_AREA_NUM )
hb_rddSelectFirstAvailable();
}
else
{
LONG lNewArea = hb_parnl( 1 );
/*
* NOTE: lNewArea >= HB_RDD_MAX_AREA_NUM used intentionally
* In Clipper area 65535 is reserved for "M" alias [druzus]
*/
if( lNewArea < 1 || lNewArea >= HB_RDD_MAX_AREA_NUM )
{
hb_rddSelectFirstAvailable();
}
else
{
hb_rddSelectWorkAreaNumber( lNewArea );
}
}
}
| dbcmd.c | 701 |
| HB_FUNC | __DBSETFOUND(void)
HB_FUNC( __DBSETFOUND )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
PHB_ITEM pFound = hb_param( 1, HB_IT_LOGICAL );
if( pFound )
pArea->fFound = hb_itemGetL( pFound );
}
}
| dbcmd.c | 731 |
| HB_FUNC | DBSETFILTER(void)
HB_FUNC( DBSETFILTER )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
PHB_ITEM pBlock, pText;
DBFILTERINFO pFilterInfo;
pBlock = hb_param( 1, HB_IT_BLOCK );
if( pBlock )
{
pText = hb_param( 2, HB_IT_STRING );
pFilterInfo.itmCobExpr = pBlock;
if( pText )
pFilterInfo.abFilterText = pText;
else
pFilterInfo.abFilterText = hb_itemPutC( NULL, NULL );
pFilterInfo.fFilter = TRUE;
pFilterInfo.lpvCargo = NULL;
pFilterInfo.fOptimized = FALSE;
SELF_SETFILTER( pArea, &pFilterInfo );
if( !pText )
hb_itemRelease( pFilterInfo.abFilterText );
}
else
{
SELF_CLEARFILTER( pArea );
}
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 743 |
| HB_FUNC | DBSKIP(void)
HB_FUNC( DBSKIP )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_SKIP( pArea, ISNUM( 1 ) ? hb_parnl( 1 ) : 1 );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 776 |
| HB_FUNC | DBSTRUCT(void)
HB_FUNC( DBSTRUCT )
{
PHB_ITEM pStruct = hb_itemArrayNew( 0 );
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
hb_tblStructure( pArea, pStruct, DBS_ALEN );
hb_itemReturnRelease( pStruct );
}
| dbcmd.c | 785 |
| HB_FUNC | DBTABLEEXT(void)
HB_FUNC( DBTABLEEXT )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
PHB_ITEM pItem = hb_itemPutC( NULL, NULL );
if( !pArea )
{
LPRDDNODE pRddNode;
USHORT uiRddID;
pRddNode = hb_rddFindNode( hb_rddDefaultDrv( NULL ), &uiRddID );
if( pRddNode )
{
pArea = ( AREAP ) hb_rddNewAreaNode( pRddNode, uiRddID );
if( pArea )
{
SELF_INFO( pArea, DBI_TABLEEXT, pItem );
SELF_RELEASE( pArea );
}
}
}
else
{
SELF_INFO( pArea, DBI_TABLEEXT, pItem );
}
hb_itemReturnRelease( pItem );
}
| dbcmd.c | 794 |
| HB_FUNC | DBUNLOCK(void)
HB_FUNC( DBUNLOCK )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_UNLOCK( pArea, NULL );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 821 |
| HB_FUNC | DBUNLOCKALL(void)
HB_FUNC( DBUNLOCKALL )
{
hb_rddUnLockAll();
}
| dbcmd.c | 831 |
| HB_FUNC | DBUSEAREA(void)
HB_FUNC( DBUSEAREA )
{
hb_retl( hb_rddOpenTable( hb_parc( 3 ), hb_parc( 2 ),
hb_parl( 1 ) ? 0 : hb_rddGetCurrentWorkAreaNumber(),
hb_parc( 4 ), ISLOG( 5 ) ? hb_parl( 5 ) : !hb_setGetExclusive(),
hb_parl( 6 ), hb_parc( 7 ), hb_parnl( 8 ), NULL, NULL ) == SUCCESS );
}
| dbcmd.c | 836 |
| HB_FUNC | __DBZAP(void)
HB_FUNC( __DBZAP )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_ZAP( pArea );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 844 |
| HB_FUNC | DELETED(void)
HB_FUNC( DELETED )
{
BOOL bDeleted = FALSE;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_DELETED( pArea, &bDeleted );
hb_retl( bDeleted );
}
| dbcmd.c | 854 |
| HB_FUNC | EOF(void)
HB_FUNC( EOF )
{
BOOL bEof = TRUE;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_EOF( pArea, &bEof );
hb_retl( bEof );
}
| dbcmd.c | 864 |
| HB_FUNC | FCOUNT(void)
HB_FUNC( FCOUNT )
{
USHORT uiFields = 0;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_FIELDCOUNT( pArea, &uiFields );
hb_retni( uiFields );
}
| dbcmd.c | 874 |
| HB_FUNC | FIELDGET(void)
HB_FUNC( FIELDGET )
{
PHB_ITEM pItem = hb_itemNew( NULL );
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
USHORT uiField = hb_parni( 1 );
if( pArea && uiField )
{
SELF_GETVALUE( pArea, uiField, pItem );
}
hb_itemReturnRelease( pItem );
}
| dbcmd.c | 884 |
| HB_FUNC | FIELDNAME(void)
HB_FUNC( FIELDNAME )
{
char * szName;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
USHORT uiFields, uiIndex = hb_parni( 1 );
if( pArea && uiIndex )
{
if( SELF_FIELDCOUNT( pArea, &uiFields ) == SUCCESS &&
uiIndex <= uiFields )
{
szName = ( char * ) hb_xgrab( pArea->uiMaxFieldNameLength + 1 );
szName[ 0 ] = '\0';
SELF_FIELDNAME( pArea, uiIndex, szName );
hb_retc_buffer( szName );
return;
}
/* This is not Clipper compatible! - David G. Holm
*
hb_errRT_DBCMD( EG_ARG, EDBCMD_FIELDNAME_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
*/
}
hb_retc( NULL );
}
| dbcmd.c | 898 |
| HB_FUNC | FIELDPOS(void)
HB_FUNC( FIELDPOS )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea && hb_parclen( 1 ) > 0 )
hb_retni( hb_rddFieldIndex( pArea, hb_parc( 1 ) ) );
else
hb_retni( 0 );
}
| dbcmd.c | 923 |
| HB_FUNC | FIELDPUT(void)
HB_FUNC( FIELDPUT )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
USHORT uiIndex = hb_parni( 1 );
if( uiIndex > 0 )
{
PHB_ITEM pItem = hb_param( 2, HB_IT_ANY );
if( pItem && !HB_IS_NIL( pItem ) )
{
if( SELF_PUTVALUE( pArea, uiIndex, pItem ) == SUCCESS )
{
hb_itemReturn( pItem );
}
}
}
}
}
| dbcmd.c | 933 |
| HB_FUNC | FLOCK(void)
HB_FUNC( FLOCK )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBLOCKINFO dbLockInfo;
dbLockInfo.fResult = FALSE;
dbLockInfo.itmRecID = NULL;
dbLockInfo.uiMethod = DBLM_FILE;
SELF_LOCK( pArea, &dbLockInfo );
hb_retl( dbLockInfo.fResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 954 |
| HB_FUNC | FOUND(void)
HB_FUNC( FOUND )
{
BOOL bFound = FALSE;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_FOUND( pArea, &bFound );
hb_retl( bFound );
}
| dbcmd.c | 971 |
| HB_FUNC | HEADER(void)
HB_FUNC( HEADER )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( !pArea )
hb_retni( 0 );
else
{
PHB_ITEM pItem = hb_itemNew( NULL );
SELF_INFO( pArea, DBI_GETHEADERSIZE, pItem );
hb_itemReturnRelease( pItem );
}
}
| dbcmd.c | 981 |
| HB_FUNC | INDEXORD(void)
HB_FUNC( INDEXORD )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pInfo;
memset( &pInfo, 0, sizeof( DBORDERINFO ) );
pInfo.itmResult = hb_itemPutNI( NULL, 0 );
SELF_ORDINFO( pArea, DBOI_NUMBER, &pInfo );
hb_retni( hb_itemGetNI( pInfo.itmResult ) );
hb_itemRelease( pInfo.itmResult );
}
else
hb_retni( 0 );
}
| dbcmd.c | 995 |
| HB_FUNC | LASTREC(void)
HB_FUNC( LASTREC )
{
ULONG ulRecCount = 0;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_RECCOUNT( pArea, &ulRecCount );
hb_retnint( ulRecCount );
}
| dbcmd.c | 1012 |
| HB_FUNC | LOCK(void)
HB_FUNC( LOCK )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBLOCKINFO dbLockInfo;
dbLockInfo.fResult = FALSE;
dbLockInfo.itmRecID = NULL;
dbLockInfo.uiMethod = DBLM_EXCLUSIVE;
SELF_LOCK( pArea, &dbLockInfo );
hb_retl( dbLockInfo.fResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1024 |
| HB_FUNC | LUPDATE(void)
HB_FUNC( LUPDATE )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
PHB_ITEM pItem = hb_itemNew( NULL );
SELF_INFO( pArea, DBI_LASTUPDATE, pItem );
hb_itemReturnRelease( pItem );
}
else
hb_retds( NULL );
}
| dbcmd.c | 1041 |
| HB_FUNC | NETERR(void)
HB_FUNC( NETERR )
{
hb_retl( hb_rddGetNetErr() );
if( ISLOG( 1 ) )
hb_rddSetNetErr( hb_parl( 1 ) );
}
| dbcmd.c | 1056 |
| HB_FUNC | ORDBAGEXT(void)
HB_FUNC( ORDBAGEXT )
{
DBORDERINFO pInfo;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
memset( &pInfo, 0, sizeof( DBORDERINFO ) );
pInfo.itmResult = hb_itemPutC( NULL, NULL );
if( !pArea )
{
LPRDDNODE pRddNode;
USHORT uiRddID;
pRddNode = hb_rddFindNode( hb_rddDefaultDrv( NULL ), &uiRddID );
if( pRddNode )
{
pArea = ( AREAP ) hb_rddNewAreaNode( pRddNode, uiRddID );
if( pArea )
{
SELF_ORDINFO( pArea, DBOI_BAGEXT, &pInfo );
SELF_RELEASE( pArea );
}
}
}
else
{
SELF_ORDINFO( pArea, DBOI_BAGEXT, &pInfo );
}
hb_itemReturnRelease( pInfo.itmResult );
}
| dbcmd.c | 1064 |
| HB_FUNC | ORDBAGNAME(void)
HB_FUNC( ORDBAGNAME )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_ANY );
if( pOrderInfo.itmOrder && !HB_IS_STRING( pOrderInfo.itmOrder ) )
{
if( HB_IS_NIL( pOrderInfo.itmOrder ) )
pOrderInfo.itmOrder = NULL;
else if( HB_IS_NUMERIC( pOrderInfo.itmOrder ) )
{
if( hb_itemGetNI( pOrderInfo.itmOrder ) == 0 )
pOrderInfo.itmOrder = NULL;
}
else
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_REL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
}
pOrderInfo.itmResult = hb_itemPutC( NULL, NULL );
SELF_ORDINFO( pArea, DBOI_BAGNAME, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1093 |
| HB_FUNC | ORDCONDSET(void)
HB_FUNC( ORDCONDSET )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
LPDBORDERCONDINFO lpdbOrdCondInfo;
PHB_ITEM pItem;
lpdbOrdCondInfo = ( LPDBORDERCONDINFO ) hb_xgrab( sizeof( DBORDERCONDINFO ) );
lpdbOrdCondInfo->abFor = hb_parclen( 1 ) > 0 ?
( BYTE * ) hb_strdup( hb_parc( 1 ) ) : NULL;
pItem = hb_param( 2, HB_IT_BLOCK );
lpdbOrdCondInfo->itmCobFor = pItem ? hb_itemNew( pItem ) : NULL;
lpdbOrdCondInfo->fAll = !ISLOG( 3 ) || hb_parl( 3 );
lpdbOrdCondInfo->abWhile = hb_parclen( 17 ) > 0 ?
( BYTE * ) hb_strdup( hb_parc( 17 ) ) : NULL;
pItem = hb_param( 4, HB_IT_BLOCK );
lpdbOrdCondInfo->itmCobWhile = pItem ? hb_itemNew( pItem ) : NULL;
pItem = hb_param( 5, HB_IT_BLOCK );
lpdbOrdCondInfo->itmCobEval = pItem ? hb_itemNew( pItem ) : NULL;
lpdbOrdCondInfo->lStep = hb_parnl( 6 );
lpdbOrdCondInfo->itmStartRecID = ISNIL( 7 ) ? NULL : hb_itemNew( hb_param( 7, HB_IT_ANY ) );
lpdbOrdCondInfo->lNextCount = hb_parnl( 8 );
lpdbOrdCondInfo->itmRecID = ISNIL( 9 ) ? NULL : hb_itemNew( hb_param( 9, HB_IT_ANY ) );
lpdbOrdCondInfo->fRest = hb_parl( 10 );
lpdbOrdCondInfo->fDescending = hb_parl( 11 );
/* 12th parameter is always nil in CL5.3, in CL5.2 it's compound flag */
lpdbOrdCondInfo->fCompound = hb_parl( 12 );
lpdbOrdCondInfo->fAdditive = hb_parl( 13 );
lpdbOrdCondInfo->fUseCurrent = hb_parl( 14 );
lpdbOrdCondInfo->fCustom = hb_parl( 15 );
lpdbOrdCondInfo->fNoOptimize = hb_parl( 16 );
/* 18th parameter in[x]Harbour is MEMORY flag added by Alexander for
DBFNTX, so far it was served in hacked way inside SELF_ORDSETCOND()
so it was working only if this method was called from ORDCONDSET()
function. I also do not like the idea that it was called MEMORY.
It should be RDD decision how such index will be served on low
level and it should be IMHO called TEMPORARY - if RDD wants then
it can make it fully in memory or in temporary file which will
be removed on index close operation */
lpdbOrdCondInfo->fTemporary = hb_parl( 18 );
/* 19th parameter is CL5.2 USEFILTER parameter which means
that RDD should respect SET FILTER and SET DELETE flag */
lpdbOrdCondInfo->fUseFilter = hb_parl( 19 );
/* 20th parameter is xHarbour extenstion and informs RDD that
index is not shared between other clients */
lpdbOrdCondInfo->fExclusive = hb_parl( 20 );
if( lpdbOrdCondInfo->itmCobWhile )
lpdbOrdCondInfo->fRest = TRUE;
if( lpdbOrdCondInfo->lNextCount || lpdbOrdCondInfo->itmRecID ||
lpdbOrdCondInfo->fRest || lpdbOrdCondInfo->fUseCurrent ||
lpdbOrdCondInfo->fUseFilter )
lpdbOrdCondInfo->fAll = FALSE;
lpdbOrdCondInfo->fActive = !lpdbOrdCondInfo->fAll ||
lpdbOrdCondInfo->abFor || lpdbOrdCondInfo->itmCobFor ||
lpdbOrdCondInfo->abWhile || lpdbOrdCondInfo->itmCobWhile ||
lpdbOrdCondInfo->fNoOptimize || lpdbOrdCondInfo->itmCobEval ||
lpdbOrdCondInfo->fTemporary;
lpdbOrdCondInfo->fScoped = !lpdbOrdCondInfo->fAll;
lpdbOrdCondInfo->lpvCargo = NULL;
hb_retl( SELF_ORDSETCOND( pArea, lpdbOrdCondInfo ) == SUCCESS );
}
else
hb_retl( FALSE );
}
| dbcmd.c | 1126 |
| HB_FUNC | ORDCREATE(void)
HB_FUNC( ORDCREATE )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERCREATEINFO dbOrderInfo;
DBCONSTRAINTINFO dbConstrInfo;
dbOrderInfo.lpdbOrdCondInfo = pArea->lpdbOrdCondInfo;
dbOrderInfo.abBagName = ( BYTE * ) hb_parcx( 1 );
dbOrderInfo.atomBagName = ( BYTE * ) hb_parcx( 2 );
dbOrderInfo.itmOrder = NULL;
dbOrderInfo.fUnique = ISLOG( 5 ) ? ( BOOL ) hb_parl( 5 ) : hb_setGetUnique();
dbOrderInfo.abExpr = hb_param( 3, HB_IT_STRING );
if( ( ( dbOrderInfo.abBagName == NULL || strlen( ( char * ) dbOrderInfo.abBagName ) == 0 ) &&
( dbOrderInfo.atomBagName == NULL || strlen( ( char * ) dbOrderInfo.atomBagName ) == 0 ) ) ||
!dbOrderInfo.abExpr )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_REL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
dbOrderInfo.itmCobExpr = hb_param( 4, HB_IT_BLOCK );
dbConstrInfo.abConstrName = ( BYTE * ) hb_parc( 6 );
dbConstrInfo.abTargetName = ( BYTE * ) hb_parc( 7 );
dbConstrInfo.itmRelationKey = hb_param( 8, HB_IT_ARRAY );
if( dbConstrInfo.abConstrName && dbConstrInfo.abTargetName && dbConstrInfo.itmRelationKey )
{
dbConstrInfo.fEnabled = hb_parl( 9 );
dbOrderInfo.lpdbConstraintInfo = &dbConstrInfo;
}
else
{
dbOrderInfo.lpdbConstraintInfo = NULL;
}
SELF_ORDCREATE( pArea, &dbOrderInfo );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1201 |
| HB_FUNC | ORDBAGCLEAR(void)
HB_FUNC( ORDBAGCLEAR )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.atomBagName = hb_param( 1, HB_IT_STRING );
if( !pOrderInfo.atomBagName )
pOrderInfo.atomBagName = hb_param( 1, HB_IT_NUMERIC );
hb_retl( SELF_ORDLSTDELETE( pArea, &pOrderInfo ) == SUCCESS );
}
else
hb_retl( FALSE );
}
| dbcmd.c | 1244 |
| HB_FUNC | ORDDESTROY(void)
HB_FUNC( ORDDESTROY )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_STRING );
if( !pOrderInfo.itmOrder )
pOrderInfo.itmOrder = hb_param( 1, HB_IT_NUMERIC );
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
hb_retl( SELF_ORDDESTROY( pArea, &pOrderInfo ) == SUCCESS );
}
else
hb_retl( FALSE );
}
| dbcmd.c | 1261 |
| HB_FUNC | ORDFOR(void)
HB_FUNC( ORDFOR )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
pOrderInfo.itmOrder = hb_param( 1, HB_IT_ANY );
if( pOrderInfo.itmOrder && !HB_IS_STRING( pOrderInfo.itmOrder ) )
{
if( HB_IS_NIL( pOrderInfo.itmOrder ) )
pOrderInfo.itmOrder = NULL;
else if( HB_IS_NUMERIC( pOrderInfo.itmOrder ) )
{
if( hb_itemGetNI( pOrderInfo.itmOrder ) == 0 )
pOrderInfo.itmOrder = NULL;
}
else
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_REL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
}
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
pOrderInfo.itmNewVal = hb_param( 3, HB_IT_STRING );
pOrderInfo.itmResult = hb_itemPutC( NULL, NULL );
pOrderInfo.itmCobExpr = NULL;
pOrderInfo.fAllTags = FALSE;
SELF_ORDINFO( pArea, DBOI_CONDITION, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1279 |
| HB_FUNC | ORDKEY(void)
HB_FUNC( ORDKEY )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_ANY );
if( pOrderInfo.itmOrder && !HB_IS_STRING( pOrderInfo.itmOrder ) )
{
if( HB_IS_NIL( pOrderInfo.itmOrder ) )
pOrderInfo.itmOrder = NULL;
else if( HB_IS_NUMERIC( pOrderInfo.itmOrder ) )
{
if( hb_itemGetNI( pOrderInfo.itmOrder ) == 0 )
pOrderInfo.itmOrder = NULL;
}
else
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_REL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
}
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
pOrderInfo.itmResult = hb_itemPutC( NULL, NULL );
SELF_ORDINFO( pArea, DBOI_EXPRESSION, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1314 |
| HB_FUNC | ORDLISTADD(void)
HB_FUNC( ORDLISTADD )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
ERRCODE errCode;
/* Clipper clears NETERR flag when index is open */
hb_rddSetNetErr( FALSE );
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.atomBagName = hb_param( 1, HB_IT_STRING );
pOrderInfo.itmOrder = hb_param( 2, HB_IT_STRING );
if( !pOrderInfo.atomBagName )
{
if( !ISNIL( 1 ) )
hb_errRT_DBCMD( EG_ARG, EDBCMD_ORDLSTADD_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
pOrderInfo.itmResult = hb_itemNew( NULL );
errCode = SELF_ORDLSTADD( pArea, &pOrderInfo );
if( !pOrderInfo.itmResult || HB_IS_NIL( pOrderInfo.itmResult ) )
hb_retl( errCode == SUCCESS );
else
hb_itemReturn( pOrderInfo.itmResult );
hb_itemRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1347 |
| HB_FUNC | ORDLISTCLEAR(void)
HB_FUNC( ORDLISTCLEAR )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_ORDLSTCLEAR( pArea );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1385 |
| HB_FUNC | ORDLISTREBUILD(void)
HB_FUNC( ORDLISTREBUILD )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_ORDLSTREBUILD( pArea );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1395 |
| HB_FUNC | ORDNAME(void)
HB_FUNC( ORDNAME )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_ANY );
if( pOrderInfo.itmOrder )
{
if( HB_IS_NIL( pOrderInfo.itmOrder ) )
pOrderInfo.itmOrder = NULL;
else if( HB_IS_NUMERIC( pOrderInfo.itmOrder ) )
{
if( hb_itemGetNI( pOrderInfo.itmOrder ) == 0 )
pOrderInfo.itmOrder = NULL;
}
else
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_REL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
}
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
pOrderInfo.itmResult = hb_itemPutC( NULL, NULL );
SELF_ORDINFO( pArea, DBOI_NAME, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1405 |
| HB_FUNC | ORDNUMBER(void)
HB_FUNC( ORDNUMBER )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_STRING );
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
if( !( pOrderInfo.itmOrder || ISNIL( 1 ) ) ||
!( pOrderInfo.atomBagName || ISNIL( 2 ) ) )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_REL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
pOrderInfo.itmResult = hb_itemPutNI( NULL, 0 );
SELF_ORDINFO( pArea, DBOI_NUMBER, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1439 |
| HB_FUNC | ORDSETFOCUS(void)
HB_FUNC( ORDSETFOCUS )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pInfo;
memset( &pInfo, 0, sizeof( DBORDERINFO ) );
pInfo.itmOrder = hb_param( 1, HB_IT_STRING );
if( !pInfo.itmOrder )
pInfo.itmOrder = hb_param( 1, HB_IT_NUMERIC );
pInfo.atomBagName = hb_param( 2, HB_IT_STRING );
pInfo.itmResult = hb_itemPutC( NULL, NULL );
SELF_ORDLSTFOCUS( pArea, &pInfo );
hb_itemReturnRelease( pInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1463 |
| HB_FUNC | RDDLIST(void)
HB_FUNC( RDDLIST )
{
hb_itemReturnRelease( hb_rddList( hb_parni( 1 ) ) );
}
| dbcmd.c | 1483 |
| HB_FUNC | RDDNAME(void)
HB_FUNC( RDDNAME )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
char pBuffer[ HB_RDD_MAX_DRIVERNAME_LEN + 1 ];
pBuffer[ 0 ] = '\0';
SELF_SYSNAME( pArea, ( BYTE * ) pBuffer );
hb_retc( pBuffer );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1488 |
| HB_FUNC | RDDREGISTER(void)
HB_FUNC( RDDREGISTER )
{
USHORT uiLen;
char szDriver[ HB_RDD_MAX_DRIVERNAME_LEN + 1 ];
uiLen = ( USHORT ) hb_parclen( 1 );
if( uiLen > 0 )
{
if( uiLen > HB_RDD_MAX_DRIVERNAME_LEN )
uiLen = HB_RDD_MAX_DRIVERNAME_LEN;
hb_strncpyUpper( szDriver, hb_parc( 1 ), uiLen );
/*
* hb_rddRegister returns:
*
* 0: Ok, RDD registered
* 1: RDD already registerd
* > 1: error
*/
if( hb_rddRegister( szDriver, hb_parni( 2 ) ) > 1 )
{
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
}
}
}
| dbcmd.c | 1503 |
| HB_FUNC | RECCOUNT(void)
HB_FUNC( RECCOUNT )
{
HB_FUNC_EXEC( LASTREC );
}
| dbcmd.c | 1529 |
| HB_FUNC | RECNO(void)
HB_FUNC( RECNO )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
PHB_ITEM pRecNo = hb_itemPutNL( NULL, 0 );
if( pArea )
{
SELF_RECID( pArea, pRecNo );
}
hb_itemReturnRelease( pRecNo );
}
| dbcmd.c | 1535 |
| HB_FUNC | RECSIZE(void)
HB_FUNC( RECSIZE )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
PHB_ITEM pItem = hb_itemNew( NULL );
SELF_INFO( pArea, DBI_GETRECSIZE, pItem );
hb_itemReturnRelease( pItem );
}
else
hb_retni( 0 );
}
| dbcmd.c | 1547 |
| HB_FUNC | RLOCK(void)
HB_FUNC( RLOCK )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBLOCKINFO dbLockInfo;
dbLockInfo.fResult = FALSE;
dbLockInfo.itmRecID = NULL;
dbLockInfo.uiMethod = DBLM_EXCLUSIVE;
SELF_LOCK( pArea, &dbLockInfo );
hb_retl( dbLockInfo.fResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1561 |
| HB_FUNC | SELECT(void)
HB_FUNC( SELECT )
{
if( hb_parinfo( 0 ) == 0 )
{
hb_retni( hb_rddGetCurrentWorkAreaNumber() );
}
else
{
char * szAlias = hb_parc( 1 );
int iArea = 0;
if( szAlias )
{
#if defined( HB_C52_STRICT ) || 1
/*
* I do not like this Clipper behavior, in some constructions
* programmer may use "" in some others not. [Druzus]
*/
if( hb_rddVerifyAliasName( szAlias ) == SUCCESS )
#endif
hb_rddGetAliasNumber( szAlias, &iArea );
}
hb_retni( iArea );
}
}
| dbcmd.c | 1578 |
| HB_FUNC | USED(void)
HB_FUNC( USED )
{
hb_retl( hb_rddGetCurrentWorkAreaPointer() != NULL );
}
| dbcmd.c | 1604 |
| HB_FUNC | RDDSETDEFAULT(void)
HB_FUNC( RDDSETDEFAULT )
{
hb_retc( hb_rddDefaultDrv( NULL ) );
if( hb_parclen( 1 ) > 0 )
{
if( ! hb_rddDefaultDrv( hb_parc( 1 ) ) )
hb_errRT_DBCMD( EG_ARG, EDBCMD_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
}
| dbcmd.c | 1609 |
| HB_FUNC | DBSETDRIVER(void)
HB_FUNC( DBSETDRIVER )
{
hb_retc( hb_rddDefaultDrv( NULL ) );
if( hb_parclen( 1 ) > 0 )
{
if( ! hb_rddDefaultDrv( hb_parc( 1 ) ) )
hb_errRT_DBCMD( EG_ARG, EDBCMD_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
}
| dbcmd.c | 1620 |
| HB_FUNC | ORDSCOPE(void)
HB_FUNC( ORDSCOPE )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pInfo;
USHORT uiAction;
int iScope = hb_parni( 1 );
memset( &pInfo, 0, sizeof( DBORDERINFO ) );
pInfo.itmResult = hb_itemNew( NULL );
if( iScope == 2 )
{
if( hb_pcount() > 1 && !ISNIL( 2 ) )
{
uiAction = DBOI_SCOPESET;
pInfo.itmNewVal = hb_param( 2, HB_IT_ANY);
}
else
uiAction = DBOI_SCOPECLEAR;
}
else
{
uiAction = ( iScope == 0 ) ? DBOI_SCOPETOP : DBOI_SCOPEBOTTOM;
if( hb_pcount() > 1 )
{
if( ISNIL( 2 ) )
uiAction = ( iScope == 0 ) ? DBOI_SCOPETOPCLEAR : DBOI_SCOPEBOTTOMCLEAR;
else
pInfo.itmNewVal = hb_param( 2, HB_IT_ANY);
}
}
SELF_ORDINFO( pArea, uiAction, &pInfo );
hb_itemReturnRelease( pInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1631 |
| HB_FUNC | DBRELATION(void)
HB_FUNC( DBRELATION ) /* () --> cLinkExp */
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
PHB_ITEM pRelExpr = hb_itemPutC( NULL, NULL );
USHORT uiRelNo = ( USHORT ) hb_parni( 1 );
SELF_RELTEXT( pArea, uiRelNo ? uiRelNo : 1, pRelExpr );
hb_itemReturnRelease( pRelExpr );
}
else
hb_retc( NULL );
}
| dbcmd.c | 1671 |
| HB_FUNC | DBRSELECT(void)
HB_FUNC( DBRSELECT ) /* () --> nWorkArea */
{
USHORT uiWorkArea = 0;
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_RELAREA( pArea, hb_parni(1), &uiWorkArea );
hb_retni( uiWorkArea );
}
| dbcmd.c | 1686 |
| HB_FUNC | DBCLEARRELATION(void)
HB_FUNC( DBCLEARRELATION )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_CLEARREL( pArea );
}
| dbcmd.c | 1697 |
| HB_FUNC | DBSETRELATION(void)
HB_FUNC( DBSETRELATION )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBRELINFO dbRelations;
AREAP pChildArea;
USHORT uiChildArea;
char * szAlias = NULL;
if( hb_pcount() < 2 || ( !( hb_parinfo( 1 ) & HB_IT_NUMERIC ) && ( hb_parinfo( 1 ) != HB_IT_STRING ) ) || !( ISNIL( 4 ) || ISLOG( 4 ) ) )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_REL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
if( hb_parinfo( 1 ) & HB_IT_NUMERIC )
{
uiChildArea = hb_parni( 1 );
}
else
{
int iArea = hb_rddGetCurrentWorkAreaNumber();
hb_rddSelectWorkAreaAlias( hb_parcx( 1 ) );
if( hb_vmRequestQuery() )
return;
uiChildArea = hb_rddGetCurrentWorkAreaNumber();
hb_rddSelectWorkAreaNumber( iArea );
}
pChildArea = uiChildArea ? ( AREAP ) hb_rddGetWorkAreaPointer( uiChildArea ) : NULL;
if( !pChildArea )
{
hb_errRT_BASE( EG_NOALIAS, EDBCMD_NOALIAS, NULL, szAlias, 0 );
return;
}
dbRelations.itmCobExpr = hb_itemNew( hb_param( 2, HB_IT_BLOCK ) );
dbRelations.abKey = hb_itemNew( hb_param( 3, HB_IT_STRING ) );
dbRelations.isScoped = hb_parl( 4 );
dbRelations.isOptimized = FALSE;
dbRelations.lpaChild = pChildArea;
dbRelations.lpaParent = pArea;
dbRelations.lpdbriNext = NULL;
SELF_SETREL( pArea, &dbRelations );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1705 |
| HB_FUNC | __DBARRANGE(void)
HB_FUNC( __DBARRANGE )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
USHORT uiNewArea, uiCount, uiDest;
ULONG ulSize;
char * szFieldLine, * szPos;
PHB_ITEM pStruct, pFields;
DBSORTINFO dbSortInfo;
memset( &dbSortInfo, 0, sizeof( DBSORTINFO ) );
dbSortInfo.dbtri.uiFlags = DBTF_PUTREC;
uiNewArea = hb_parni( 1 );
/* Fields structure of source WorkArea */
pStruct = hb_param( 2 , HB_IT_ARRAY );
if( pStruct )
{
dbSortInfo.dbtri.uiItemCount = ( USHORT ) hb_arrayLen( pStruct );
if( dbSortInfo.dbtri.uiItemCount > 0 )
{
dbSortInfo.dbtri.lpTransItems = ( LPDBTRANSITEM )
hb_xgrab( dbSortInfo.dbtri.uiItemCount *
sizeof( DBTRANSITEM ) );
for( uiCount = 0; uiCount < dbSortInfo.dbtri.uiItemCount; ++uiCount )
{
pFields = hb_arrayGetItemPtr( pStruct, uiCount + 1 );
if( HB_IS_ARRAY( pFields ) && hb_arrayLen( pFields ) > 0 )
{
dbSortInfo.dbtri.lpTransItems[ uiCount ].uiSource =
dbSortInfo.dbtri.lpTransItems[ uiCount ].uiDest =
hb_rddFieldIndex( pArea, hb_arrayGetCPtr( pFields, 1 ) );
}
else
{
hb_xfree( dbSortInfo.dbtri.lpTransItems );
dbSortInfo.dbtri.lpTransItems = NULL;
dbSortInfo.dbtri.uiItemCount = 0;
break;
}
}
}
}
else
return;
/* Invalid fields structure? */
if( dbSortInfo.dbtri.uiItemCount == 0 )
return;
dbSortInfo.dbtri.dbsci.itmCobFor = hb_param( 3, HB_IT_BLOCK );
dbSortInfo.dbtri.dbsci.lpstrFor = NULL;
dbSortInfo.dbtri.dbsci.itmCobWhile = hb_param( 4, HB_IT_BLOCK );
dbSortInfo.dbtri.dbsci.lpstrWhile = NULL;
dbSortInfo.dbtri.dbsci.lNext = hb_param( 5, HB_IT_NUMERIC );
dbSortInfo.dbtri.dbsci.itmRecID = ISNIL( 6 ) ? NULL : hb_param( 6, HB_IT_ANY );
dbSortInfo.dbtri.dbsci.fRest = hb_param( 7, HB_IT_LOGICAL );
dbSortInfo.dbtri.dbsci.fIgnoreFilter =
dbSortInfo.dbtri.dbsci.fLast =
dbSortInfo.dbtri.dbsci.fIgnoreDuplicates =
dbSortInfo.dbtri.dbsci.fBackward =
dbSortInfo.dbtri.dbsci.fOptimized = FALSE;
dbSortInfo.dbtri.dbsci.fIncludeDeleted = TRUE;
pFields = hb_param( 8, HB_IT_ARRAY );
dbSortInfo.uiItemCount = pFields ? ( USHORT ) hb_arrayLen( pFields ) : 0;
if( dbSortInfo.uiItemCount > 0 )
{
dbSortInfo.lpdbsItem = ( LPDBSORTITEM ) hb_xgrab( dbSortInfo.uiItemCount * sizeof( DBSORTITEM ) );
ulSize = 0;
for( uiCount = 1; uiCount <= dbSortInfo.uiItemCount; ++uiCount )
{
ULONG ulLine = hb_arrayGetCLen( pFields, uiCount );
if( ulLine > ulSize )
ulSize = ulLine;
}
szFieldLine = ( char * ) hb_xgrab( ulSize + 1 );
for( uiCount = uiDest = 0; uiCount < dbSortInfo.uiItemCount; ++uiCount )
{
dbSortInfo.lpdbsItem[ uiDest ].uiFlags = 0;
hb_strncpyUpper( szFieldLine, hb_arrayGetCPtr( pFields, uiCount + 1 ),
hb_arrayGetCLen( pFields, uiCount + 1 ) );
szPos = strchr( szFieldLine, '/' );
if( szPos )
{
*szPos++ = 0;
if( strchr( szPos, 'D' ) > strchr( szPos, 'A' ) )
dbSortInfo.lpdbsItem[ uiDest ].uiFlags |= SF_DESCEND;
else
dbSortInfo.lpdbsItem[ uiDest ].uiFlags |= SF_ASCEND;
if( strchr( szPos, 'C' ) != NULL )
dbSortInfo.lpdbsItem[ uiDest ].uiFlags |= SF_CASE;
}
else
{
dbSortInfo.lpdbsItem[ uiDest ].uiFlags |= SF_ASCEND;
}
dbSortInfo.lpdbsItem[ uiDest ].uiField = hb_rddFieldExpIndex( pArea, szFieldLine );
/* Field found */
if( dbSortInfo.lpdbsItem[ uiDest ].uiField != 0 )
{
++uiDest;
}
}
dbSortInfo.uiItemCount = uiDest;
hb_xfree( szFieldLine );
}
dbSortInfo.dbtri.lpaSource = pArea;
dbSortInfo.dbtri.lpaDest = ( AREAP ) hb_rddGetWorkAreaPointer( uiNewArea );
/* TODO: check what Clipper does when lpaDest == NULL or lpaDest == lpaSource */
if( dbSortInfo.uiItemCount == 0 )
SELF_TRANS( pArea, &dbSortInfo.dbtri );
else
SELF_SORT( pArea, &dbSortInfo );
/* Free items */
if( dbSortInfo.lpdbsItem )
hb_xfree( dbSortInfo.lpdbsItem );
if( dbSortInfo.dbtri.lpTransItems )
hb_xfree( dbSortInfo.dbtri.lpTransItems );
}
}
| dbcmd.c | 1759 |
| HB_FUNC | __DBTRANS(void)
HB_FUNC( __DBTRANS )
{
if( ISNUM( 1 ) )
{
USHORT uiSrcArea, uiDstArea;
AREAP pSrcArea, pDstArea;
uiSrcArea = hb_rddGetCurrentWorkAreaNumber();
pSrcArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
uiDstArea = hb_parni( 1 );
hb_rddSelectWorkAreaNumber( uiDstArea );
pDstArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pSrcArea && pDstArea )
{
DBTRANSINFO dbTransInfo;
PHB_ITEM pFields = hb_param( 2, HB_IT_ARRAY );
ERRCODE errCode;
memset( &dbTransInfo, 0, sizeof( DBTRANSINFO ) );
errCode = hb_dbTransStruct( pSrcArea, pDstArea, &dbTransInfo,
NULL, pFields );
if( errCode == SUCCESS )
{
hb_rddSelectWorkAreaNumber( dbTransInfo.lpaSource->uiArea );
dbTransInfo.dbsci.itmCobFor = hb_param( 3, HB_IT_BLOCK );
dbTransInfo.dbsci.lpstrFor = NULL;
dbTransInfo.dbsci.itmCobWhile = hb_param( 4, HB_IT_BLOCK );
dbTransInfo.dbsci.lpstrWhile = NULL;
dbTransInfo.dbsci.lNext = hb_param( 5, HB_IT_NUMERIC );
dbTransInfo.dbsci.itmRecID = ISNIL( 6 ) ? NULL : hb_param( 6, HB_IT_ANY );
dbTransInfo.dbsci.fRest = hb_param( 7, HB_IT_LOGICAL );
dbTransInfo.dbsci.fIgnoreFilter = TRUE;
dbTransInfo.dbsci.fIncludeDeleted = TRUE;
dbTransInfo.dbsci.fLast = FALSE;
dbTransInfo.dbsci.fIgnoreDuplicates = FALSE;
dbTransInfo.dbsci.fBackward = FALSE;
errCode = SELF_TRANS( dbTransInfo.lpaSource, &dbTransInfo );
}
if( dbTransInfo.lpTransItems )
hb_xfree( dbTransInfo.lpTransItems );
hb_retl( errCode == SUCCESS );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
hb_rddSelectWorkAreaNumber( uiSrcArea );
}
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_USE_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 1888 |
| HB_FUNC | __DBAPP(void)
HB_FUNC( __DBAPP )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
hb_retl( SUCCESS == hb_rddTransRecords( pArea,
hb_parc( 1 ), /* file name */
hb_parc( 8 ), /* RDD */
hb_parnl( 9 ), /* connection */
hb_param( 2, HB_IT_ARRAY ), /* Fields */
FALSE, /* Export? */
hb_param( 3, HB_IT_BLOCK ), /* cobFor */
NULL, /* lpStrFor */
hb_param( 4, HB_IT_BLOCK ), /* cobWhile */
NULL, /* lpStrWhile */
hb_param( 5, HB_IT_NUMERIC ), /* Next */
ISNIL( 6 ) ? NULL : hb_param( 6, HB_IT_ANY ), /* RecID */
hb_param( 7, HB_IT_LOGICAL ), /* Rest */
hb_parc( 10 ), /* Codepage */
hb_param( 11, HB_IT_ANY ) ) ); /* Delimiter */
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, "APPEND FROM" );
}
| dbcmd.c | 1946 |
| HB_FUNC | __DBCOPY(void)
HB_FUNC( __DBCOPY )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
hb_retl( SUCCESS == hb_rddTransRecords( pArea,
hb_parc( 1 ), /* file name */
hb_parc( 8 ), /* RDD */
hb_parnl( 9 ), /* connection */
hb_param( 2, HB_IT_ARRAY ), /* Fields */
TRUE, /* Export? */
hb_param( 3, HB_IT_BLOCK ), /* cobFor */
NULL, /* lpStrFor */
hb_param( 4, HB_IT_BLOCK ), /* cobWhile */
NULL, /* lpStrWhile */
hb_param( 5, HB_IT_NUMERIC ), /* Next */
ISNIL( 6 ) ? NULL : hb_param( 6, HB_IT_ANY ), /* RecID */
hb_param( 7, HB_IT_LOGICAL ), /* Rest */
hb_parc( 10 ), /* Codepage */
hb_param( 11, HB_IT_ANY ) ) ); /* Delimiter */
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, "COPY TO" );
}
| dbcmd.c | 1969 |
| HB_FUNC | HB_RDDGETTEMPALIAS(void)
HB_FUNC( HB_RDDGETTEMPALIAS )
{
char szAliasTmp[ HB_RDD_MAX_ALIAS_LEN + 1 ];
if( hb_rddGetTempAlias( szAliasTmp ) == SUCCESS )
hb_retc( szAliasTmp );
}
| dbcmd.c | 1992 |
| HB_FUNC | __RDDGETTEMPALIAS(void)
HB_FUNC( __RDDGETTEMPALIAS )
{
HB_FUNC_EXEC( HB_RDDGETTEMPALIAS )
}
| dbcmd.c | 2000 |
| HB_FUNC | HB_RDDINFO(void)
HB_FUNC( HB_RDDINFO )
{
LPRDDNODE pRDDNode;
USHORT uiRddID;
ULONG ulConnection;
PHB_ITEM pIndex, pParam;
const char * szDriver;
szDriver = hb_parc( 3 );
if( !szDriver ) /* no VIA RDD parameter, use default */
{
szDriver = hb_rddDefaultDrv( NULL );
}
ulConnection = hb_parnl( 4 );
pRDDNode = hb_rddFindNode( szDriver, &uiRddID ); /* find the RDDNODE */
pIndex = hb_param( 1, HB_IT_NUMERIC );
pParam = hb_param( 2, HB_IT_ANY );
if( pRDDNode && pIndex )
{
PHB_ITEM pInfo = hb_itemNew( pParam );
SELF_RDDINFO( pRDDNode, hb_itemGetNI( pIndex ), ulConnection, pInfo );
hb_itemReturnRelease( pInfo );
}
else
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_EVAL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
}
| dbcmd.c | 2006 |
| HB_FUNC | HB_DBDROP(void)
HB_FUNC( HB_DBDROP )
{
LPRDDNODE pRDDNode;
USHORT uiRddID;
ULONG ulConnection;
const char * szDriver;
PHB_ITEM pName;
szDriver = hb_parc( 3 );
if( !szDriver ) /* no VIA RDD parameter, use default */
{
szDriver = hb_rddDefaultDrv( NULL );
}
ulConnection = hb_parnl( 4 );
pRDDNode = hb_rddFindNode( szDriver, &uiRddID ); /* find the RDDNODE */
pName = hb_param( 1, HB_IT_STRING );
if( pRDDNode && pName )
hb_retl( SELF_DROP( pRDDNode, pName, hb_param( 2, HB_IT_STRING ),
ulConnection ) == SUCCESS );
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_EVAL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 2037 |
| HB_FUNC | HB_DBEXISTS(void)
HB_FUNC( HB_DBEXISTS )
{
LPRDDNODE pRDDNode;
USHORT uiRddID;
ULONG ulConnection;
const char * szDriver;
PHB_ITEM pName;
szDriver = hb_parc( 3 );
if( !szDriver ) /* no VIA RDD parameter, use default */
{
szDriver = hb_rddDefaultDrv( NULL );
}
ulConnection = hb_parnl( 4 );
pRDDNode = hb_rddFindNode( szDriver, &uiRddID ); /* find the RDD */
pName = hb_param( 1, HB_IT_STRING );
if( pRDDNode && pName )
hb_retl( SELF_EXISTS( pRDDNode, pName, hb_param( 2, HB_IT_STRING ),
ulConnection ) == SUCCESS );
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_EVAL_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
| dbcmd.c | 2062 |
| HB_FUNC | HB_FIELDLEN(void)
HB_FUNC( HB_FIELDLEN )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
USHORT uiIndex;
if( ( uiIndex = hb_parni( 1 ) ) > 0 )
{
PHB_ITEM pItem = hb_itemNew( NULL );
if( SELF_FIELDINFO( pArea, uiIndex, DBS_LEN, pItem ) == SUCCESS )
{
hb_itemReturnRelease( pItem );
return;
}
hb_itemRelease( pItem );
}
}
hb_retni( 0 );
}
| dbcmd.c | 2087 |
| HB_FUNC | HB_FIELDDEC(void)
HB_FUNC( HB_FIELDDEC )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
USHORT uiIndex;
if( ( uiIndex = hb_parni( 1 ) ) > 0 )
{
PHB_ITEM pItem = hb_itemNew( NULL );
if( SELF_FIELDINFO( pArea, uiIndex, DBS_DEC, pItem ) == SUCCESS )
{
hb_itemReturnRelease( pItem );
return;
}
hb_itemRelease( pItem );
}
}
hb_retni( 0 );
}
| dbcmd.c | 2111 |
| HB_FUNC | HB_FIELDTYPE(void)
HB_FUNC( HB_FIELDTYPE )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
USHORT uiIndex;
if( ( uiIndex = hb_parni( 1 ) ) > 0 )
{
PHB_ITEM pItem = hb_itemNew( NULL );
if( SELF_FIELDINFO( pArea, uiIndex, DBS_TYPE, pItem ) == SUCCESS )
{
hb_itemReturnRelease( pItem );
return;
}
hb_itemRelease( pItem );
}
}
hb_retc( NULL );
}
| dbcmd.c | 2135 |
| dbcmd53.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | ORDKEYCOUNT(void)
HB_FUNC( ORDKEYCOUNT )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_STRING );
if( !pOrderInfo.itmOrder )
pOrderInfo.itmOrder = hb_param( 1, HB_IT_NUMERIC );
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
/* Either or both may be NIL */
pOrderInfo.itmResult = hb_itemPutNL( NULL, 0 );
SELF_ORDINFO( pArea, DBOI_KEYCOUNT, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 73 |
| HB_FUNC | ORDKEYNO(void)
HB_FUNC( ORDKEYNO )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_STRING );
if( !pOrderInfo.itmOrder )
pOrderInfo.itmOrder = hb_param( 1, HB_IT_NUMERIC );
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
/* Either or both may be NIL */
pOrderInfo.itmNewVal = NULL;
pOrderInfo.itmResult = hb_itemPutNL( NULL, 0 );
SELF_ORDINFO( pArea, DBOI_POSITION, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 96 |
| HB_FUNC | ORDKEYGOTO(void)
HB_FUNC( ORDKEYGOTO )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmNewVal = hb_param( 1 , HB_IT_NUMERIC );
pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
SELF_ORDINFO( pArea, DBOI_POSITION, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 118 |
| HB_FUNC | ORDKEYRELPOS(void)
HB_FUNC( ORDKEYRELPOS )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmNewVal = hb_param( 1 , HB_IT_NUMERIC );
pOrderInfo.itmResult = hb_itemPutNI( NULL, 0 );
SELF_ORDINFO( pArea, DBOI_RELKEYPOS, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 135 |
| HB_FUNC | ORDFINDREC(void)
HB_FUNC( ORDFINDREC )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmNewVal = hb_param( 1 , HB_IT_NUMERIC );
pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
SELF_ORDINFO( pArea, ISLOG( 2 ) && hb_parl( 2 ) ? DBOI_FINDRECCONT :
DBOI_FINDREC, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 152 |
| HB_FUNC | ORDSKIPRAW(void)
HB_FUNC( ORDSKIPRAW )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
SELF_SKIPRAW( pArea, ISNUM( 1 ) ? hb_parnl( 1 ) : 1 );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 170 |
| HB_FUNC | ORDSKIPUNIQUE(void)
HB_FUNC( ORDSKIPUNIQUE )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmNewVal = hb_param( 1, HB_IT_ANY );
pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
SELF_ORDINFO( pArea, DBOI_SKIPUNIQUE, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 180 |
| HB_FUNC | ORDKEYVAL(void)
HB_FUNC( ORDKEYVAL )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmResult = hb_itemNew( NULL );
SELF_ORDINFO( pArea, DBOI_KEYVAL, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 197 |
| HB_FUNC | ORDKEYADD(void)
HB_FUNC( ORDKEYADD )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_STRING );
if( !pOrderInfo.itmOrder )
pOrderInfo.itmOrder = hb_param( 1, HB_IT_NUMERIC );
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
/* Either or both may be NIL */
pOrderInfo.itmNewVal = hb_param( 3 , HB_IT_ANY );
pOrderInfo.itmResult = hb_itemPutNL( NULL, 0 );
SELF_ORDINFO( pArea, DBOI_KEYADD, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 213 |
| HB_FUNC | ORDKEYDEL(void)
HB_FUNC( ORDKEYDEL )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_STRING );
if( !pOrderInfo.itmOrder )
pOrderInfo.itmOrder = hb_param( 1, HB_IT_NUMERIC );
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
/* Either or both may be NIL */
pOrderInfo.itmNewVal = hb_param( 3 , HB_IT_ANY );
pOrderInfo.itmResult = hb_itemPutNL( NULL, 0 );
SELF_ORDINFO( pArea, DBOI_KEYDELETE, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 235 |
| HB_FUNC | ORDDESCEND(void)
HB_FUNC( ORDDESCEND )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_STRING );
if( !pOrderInfo.itmOrder )
pOrderInfo.itmOrder = hb_param( 1, HB_IT_NUMERIC );
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
/* Either or both may be NIL */
pOrderInfo.itmNewVal = hb_param( 3 , HB_IT_LOGICAL );
pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
SELF_ORDINFO( pArea, DBOI_ISDESC, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 257 |
| HB_FUNC | ORDISUNIQUE(void)
HB_FUNC( ORDISUNIQUE )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_STRING );
if( !pOrderInfo.itmOrder )
pOrderInfo.itmOrder = hb_param( 1, HB_IT_NUMERIC );
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
/* HARBOUR extension: NewVal to set/reset unique flag */
pOrderInfo.itmNewVal = hb_param( 3 , HB_IT_LOGICAL );
pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
SELF_ORDINFO( pArea, DBOI_UNIQUE, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 279 |
| HB_FUNC | ORDCUSTOM(void)
HB_FUNC( ORDCUSTOM )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.itmOrder = hb_param( 1, HB_IT_STRING );
if( !pOrderInfo.itmOrder )
pOrderInfo.itmOrder = hb_param( 1, HB_IT_NUMERIC );
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
/* Either or both may be NIL */
pOrderInfo.itmNewVal = hb_param( 3 , HB_IT_LOGICAL );
pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
SELF_ORDINFO( pArea, DBOI_CUSTOM, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 301 |
| HB_FUNC | ORDCOUNT(void)
HB_FUNC( ORDCOUNT )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
pOrderInfo.atomBagName = hb_param( 1, HB_IT_STRING );
pOrderInfo.itmResult = hb_itemPutNI( NULL, 0 );
SELF_ORDINFO( pArea, DBOI_ORDERCOUNT, &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 323 |
| HB_FUNC | DBINFO(void)
HB_FUNC( DBINFO )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
PHB_ITEM pIndex;
pIndex = hb_param( 1, HB_IT_NUMERIC );
if( pIndex )
{
PHB_ITEM pInfo = hb_itemNew( hb_param( 2, HB_IT_ANY ) );
SELF_INFO( pArea, hb_itemGetNI( pIndex ), pInfo );
hb_itemReturnRelease( pInfo );
}
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBINFOBADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 340 |
| HB_FUNC | DBORDERINFO(void)
HB_FUNC( DBORDERINFO )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
PHB_ITEM pType = hb_param( 1 , HB_IT_NUMERIC );
if( pType )
{
DBORDERINFO pOrderInfo;
/* atomBagName may be NIL */
pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
if( !pOrderInfo.atomBagName )
pOrderInfo.atomBagName = hb_param( 2, HB_IT_NUMERIC );
pOrderInfo.itmOrder = hb_param( 3, HB_IT_STRING );
if( !pOrderInfo.itmOrder )
pOrderInfo.itmOrder = hb_param( 3, HB_IT_NUMERIC );
pOrderInfo.itmNewVal = hb_param( 4 , HB_IT_ANY );
pOrderInfo.itmResult = hb_itemNew( NULL );
pOrderInfo.itmCobExpr = NULL;
pOrderInfo.fAllTags = FALSE;
SELF_ORDINFO( pArea, hb_itemGetNI( pType ), &pOrderInfo );
hb_itemReturnRelease( pOrderInfo.itmResult );
}
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBCMDBADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 363 |
| HB_FUNC | DBFIELDINFO(void)
HB_FUNC( DBFIELDINFO )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
USHORT uiFields, uiIndex;
PHB_ITEM pType;
pType = hb_param( 1 , HB_IT_NUMERIC );
uiIndex = hb_parni( 2 );
if( pType && SELF_FIELDCOUNT( pArea, &uiFields ) == SUCCESS &&
uiIndex > 0 && uiIndex <= uiFields )
{
PHB_ITEM pInfo = hb_itemNew( hb_param( 3, HB_IT_ANY ) );
SELF_FIELDINFO( pArea, uiIndex, hb_itemGetNI( pType ), pInfo );
hb_itemReturnRelease( pInfo );
}
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBCMDBADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 397 |
| HB_FUNC | DBRECORDINFO(void)
HB_FUNC( DBRECORDINFO )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
PHB_ITEM pType, pRecNo;
pType = hb_param( 1, HB_IT_NUMERIC );
pRecNo = hb_param( 2, HB_IT_ANY );
if( pType )
{
PHB_ITEM pInfo = hb_itemNew( hb_param( 3, HB_IT_ANY ) );
SELF_RECINFO( pArea, pRecNo, hb_itemGetNI( pType ), pInfo );
hb_itemReturnRelease( pInfo );
}
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_INFOBADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 423 |
| HB_FUNC | DBFILEGET(void)
HB_FUNC( DBFILEGET )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
USHORT uiFields, uiIndex;
PHB_ITEM pMode;
char * szField = hb_parc( 1 );
if( szField )
uiIndex = hb_rddFieldIndex( pArea, szField );
else
uiIndex = hb_parni( 1 );
pMode = hb_param( 3, HB_IT_NUMERIC );
if( uiIndex > 0 && pMode && hb_parclen( 2 ) > 0 &&
SELF_FIELDCOUNT( pArea, &uiFields ) == SUCCESS &&
uiIndex <= uiFields )
{
hb_retl( SELF_GETVALUEFILE( pArea, uiIndex, hb_parc( 2 ),
hb_itemGetNI( pMode ) ) == SUCCESS );
}
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBFILEGETBADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 447 |
| HB_FUNC | DBFILEPUT(void)
HB_FUNC( DBFILEPUT )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
USHORT uiFields, uiIndex;
char * szField = hb_parc( 1 );
if( szField )
uiIndex = hb_rddFieldIndex( pArea, szField );
else
uiIndex = hb_parni( 1 );
if( uiIndex > 0 && hb_parclen( 2 ) > 0 &&
SELF_FIELDCOUNT( pArea, &uiFields ) == SUCCESS &&
uiIndex <= uiFields )
{
hb_retl( SELF_PUTVALUEFILE( pArea, uiIndex, hb_parc( 2 ),
hb_parni( 3 ) ) == SUCCESS );
}
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBFILEPUTBADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmd53.c | 480 |
| dbcmdhb.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_DBPACK(void)
HB_FUNC( HB_DBPACK )
{
HB_FUNC_EXEC( __DBPACK );
}
HB_FUNC_EXTERN( __DBZAP );
| dbcmdhb.c | 57 |
| HB_FUNC | HB_DBZAP(void)
HB_FUNC( HB_DBZAP )
{
HB_FUNC_EXEC( __DBZAP );
}
| dbcmdhb.c | 64 |
| dbcmdx.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | DBPACK(void)
HB_FUNC( DBPACK )
{
HB_FUNC_EXEC( HB_DBPACK );
}
HB_FUNC_EXTERN( HB_DBZAP );
| dbcmdx.c | 63 |
| HB_FUNC | DBZAP(void)
HB_FUNC( DBZAP )
{
HB_FUNC_EXEC( HB_DBZAP );
}
| dbcmdx.c | 70 |
| HB_FUNC | ORDWILDSEEK(void)
HB_FUNC( ORDWILDSEEK )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
char * szPattern = hb_parc( 1 );
if( szPattern )
{
BOOL fCont = hb_parl( 2 ), fBack = hb_parl( 3 ), fFound = FALSE;
DBORDERINFO OrderInfo;
ERRCODE errCode = SUCCESS;
memset( &OrderInfo, 0, sizeof( DBORDERINFO ) );
OrderInfo.itmResult = hb_itemNew( NULL );
if( !fCont )
{
char * szKey;
if( fBack )
errCode = SELF_GOBOTTOM( pArea );
else
errCode = SELF_GOTOP( pArea );
if( errCode == SUCCESS )
{
errCode = SELF_ORDINFO( pArea, DBOI_KEYVAL, &OrderInfo );
if( errCode == SUCCESS )
{
szKey = hb_itemGetCPtr( OrderInfo.itmResult );
fFound = hb_strMatchWild( szKey, szPattern );
}
}
}
if( !fFound && errCode == SUCCESS )
{
OrderInfo.itmNewVal = hb_param( 1, HB_IT_STRING );
if( SELF_ORDINFO( pArea, fBack ? DBOI_SKIPWILDBACK : DBOI_SKIPWILD,
&OrderInfo ) == SUCCESS )
fFound = hb_itemGetL( OrderInfo.itmResult );
}
hb_itemRelease( OrderInfo.itmResult );
hb_retl( fFound );
}
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBFILEPUTBADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmdx.c | 75 |
| HB_FUNC | DBSKIPPER(void)
HB_FUNC( DBSKIPPER )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
LONG lSkipped = 0;
LONG lRecs = 1;
BOOL fBEof;
ULONG ulRecords = 0;
if( SELF_RECCOUNT( pArea, &ulRecords ) == SUCCESS && ulRecords > 0 )
{
if( ISNUM( 1 ) )
lRecs = hb_parnl( 1 );
if( lRecs == 0 )
SELF_SKIP( pArea, 0 );
else if( lRecs > 0 )
{
if( SELF_EOF( pArea, &fBEof ) == SUCCESS )
{
while( lSkipped < lRecs )
{
if( SELF_SKIP( pArea, 1 ) != SUCCESS )
break;
if( SELF_EOF( pArea, &fBEof ) != SUCCESS )
break;
if( fBEof )
{
SELF_SKIP( pArea, -1 );
break;
}
lSkipped++;
}
}
}
else /* if( lRecs < 0 ) */
{
while( lSkipped > lRecs )
{
if( SELF_SKIP( pArea, -1 ) != SUCCESS )
break;
if( SELF_BOF( pArea, &fBEof ) != SUCCESS )
break;
if( fBEof )
break;
lSkipped--;
}
}
}
hb_retnl( lSkipped );
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbcmdx.c | 128 |
| dbdetach.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | HB_DBDETACH(void)
HB_FUNC( HB_DBDETACH )
{
PHB_ITEM pAlias = hb_param( 1, HB_IT_ANY );
PHB_ITEM pCargo = hb_param( 2, HB_IT_ANY ); /* HB_IT_BLOCK in xBase++ */
AREAP pArea = NULL;
int iArea;
if( !pAlias || HB_IS_NIL( pAlias ) )
{
pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
}
else if( HB_IS_STRING( pAlias ) )
{
char * szAlias = hb_itemGetCPtr( pAlias );
hb_rddGetAliasNumber( szAlias, &iArea );
if( iArea > 0 )
pArea = ( AREAP ) hb_rddGetWorkAreaPointer( iArea );
}
else if( HB_IS_NUMBER( pAlias ) )
{
iArea = hb_itemGetNI( pAlias );
if( iArea > 0 )
pArea = ( AREAP ) hb_rddGetWorkAreaPointer( iArea );
}
else
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return;
}
if( pArea )
hb_retl( hb_rddDetachArea( pArea, pCargo ) == SUCCESS );
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbdetach.c | 58 |
| HB_FUNC | HB_DBREQUEST(void)
HB_FUNC( HB_DBREQUEST )
{
char * szAlias;
PHB_ITEM pCargo;
BOOL fNewArea, fWait;
AREAP pArea;
if( ISNIL( 1 ) || ISCHAR( 1 ) )
{
szAlias = hb_parc( 1 );
fNewArea = ISLOG( 2 ) && hb_parl( 2 );
fWait = ISLOG( 4 ) && hb_parl( 4 );
pCargo = ISBYREF( 3 ) ? hb_itemNew( NULL ) : NULL;
pArea = hb_rddRequestArea( szAlias, pCargo, fNewArea, fWait );
if( pArea )
hb_rddSelectWorkAreaNumber( pArea->uiArea );
if( pCargo )
{
hb_itemParamStoreForward( 3, pCargo );
hb_itemRelease( pCargo );
}
hb_retl( pArea != NULL );
}
else
hb_errRT_DBCMD( EG_ARG, EDBCMD_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
}
| dbdetach.c | 97 |
| HB_FUNC | DBRELEASE(void)
HB_FUNC( DBRELEASE )
{
HB_FUNC_EXEC( HB_DBDETACH );
}
| dbdetach.c | 132 |
| HB_FUNC | DBREQUEST(void)
HB_FUNC( DBREQUEST )
{
HB_FUNC_EXEC( HB_DBREQUEST );
}
| dbdetach.c | 137 |
| dbdrop.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | DBDROP(void)
HB_FUNC( DBDROP )
{
HB_FUNC_EXEC( HB_DBDROP );
}
| dbdrop.c | 62 |
| dbexists.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | DBEXISTS(void)
HB_FUNC( DBEXISTS )
{
HB_FUNC_EXEC( HB_DBEXISTS );
}
| dbexists.c | 62 |
| dbf1.c |
| Type | Function | Source | Line |
|---|
| STATIC HB_LONG | hb_dbfGetRowVer( DBFAREAP pArea, USHORT uiField, HB_LONG * pValue )
static HB_LONG hb_dbfGetRowVer( DBFAREAP pArea, USHORT uiField, HB_LONG * pValue )
{
DBFFIELD dbField;
BOOL fLck = FALSE;
*pValue = 0;
if( pArea->fShared && !pArea->fFLocked && !pArea->fHeaderLocked )
{
if( SELF_RAWLOCK( ( AREAP ) pArea, HEADER_LOCK, 0 ) != SUCCESS )
return FAILURE;
fLck = TRUE;
}
if( hb_fileReadAt( pArea->pDataFile, ( BYTE * ) &dbField, sizeof( dbField ),
sizeof( DBFHEADER ) + uiField * sizeof( DBFFIELD ) ) ==
sizeof( dbField ) )
{
*pValue = HB_GET_LE_UINT64( &dbField.bReserved2 ) + 1;
HB_PUT_LE_UINT64( dbField.bReserved2, *pValue );
hb_fileWriteAt( pArea->pDataFile, ( BYTE * ) &dbField, sizeof( dbField ),
sizeof( DBFHEADER ) + uiField * sizeof( DBFFIELD ) );
}
if( fLck )
{
if( SELF_RAWLOCK( ( AREAP ) pArea, HEADER_UNLOCK, 0 ) != SUCCESS )
return FAILURE;
}
return SUCCESS;
}
| dbf1.c | 190 |
| STATIC HB_LONG | hb_dbfGetNextValue( DBFAREAP pArea, USHORT uiField )
static HB_LONG hb_dbfGetNextValue( DBFAREAP pArea, USHORT uiField )
{
HB_LONG nValue = 0;
DBFFIELD dbField;
if( hb_fileReadAt( pArea->pDataFile, ( BYTE * ) &dbField, sizeof( dbField ),
sizeof( DBFHEADER ) + uiField * sizeof( DBFFIELD ) ) ==
sizeof( dbField ) )
{
nValue = HB_GET_LE_UINT32( dbField.bCounter );
HB_PUT_LE_UINT32( dbField.bCounter, nValue + dbField.bStep );
hb_fileWriteAt( pArea->pDataFile, ( BYTE * ) &dbField, sizeof( dbField ),
sizeof( DBFHEADER ) + uiField * sizeof( DBFFIELD ) );
}
return nValue;
}
| dbf1.c | 222 |
| STATIC VOID | hb_dbfUpdateStampFields( DBFAREAP pArea )
static void hb_dbfUpdateStampFields( DBFAREAP pArea )
{
LONG lJulian = 0, lMilliSec = 0;
HB_LONG nRowVer = 0;
LPFIELD pField;
USHORT uiCount;
for( uiCount = 0, pField = pArea->lpFields; uiCount < pArea->uiFieldCount; uiCount++, pField++ )
{
switch( pField->uiType )
{
case HB_FT_MODTIME:
{
BYTE * pPtr = pArea->pRecord + pArea->pFieldOffset[ uiCount ];
if( lJulian == 0 )
hb_dateTimeStamp( &lJulian, &lMilliSec );
HB_PUT_LE_UINT32( pPtr, lJulian );
pPtr += 4;
HB_PUT_LE_UINT32( pPtr, lMilliSec );
break;
}
case HB_FT_ROWVER:
{
BYTE * pPtr = pArea->pRecord + pArea->pFieldOffset[ uiCount ];
if( nRowVer == 0 )
hb_dbfGetRowVer( pArea, uiCount, &nRowVer );
HB_PUT_LE_UINT64( pPtr, nRowVer );
break;
}
}
}
}
| dbf1.c | 240 |
| STATIC VOID | hb_dbfSetBlankRecord( DBFAREAP pArea, int iType )
static void hb_dbfSetBlankRecord( DBFAREAP pArea, int iType )
{
BYTE *pPtr = pArea->pRecord, bFill = ' ', bNext;
ULONG ulSize = 1; /* 1 byte ' ' for DELETE flag */
USHORT uiCount;
LPFIELD pField;
for( uiCount = 0, pField = pArea->lpFields; uiCount < pArea->uiFieldCount; uiCount++, pField++ )
{
USHORT uiLen = pField->uiLen;
switch( pField->uiType )
{
case HB_FT_MEMO:
case HB_FT_IMAGE:
case HB_FT_BLOB:
case HB_FT_OLE:
bNext = uiLen == 10 ? ' ' : '\0';
break;
case HB_FT_DATE:
bNext = uiLen == 8 ? ' ' : '\0';
break;
case HB_FT_STRING:
case HB_FT_LOGICAL:
bNext = ' ';
break;
case HB_FT_LONG:
case HB_FT_FLOAT:
if( pField->uiFlags & HB_FF_AUTOINC )
{
if( iType == HB_BLANK_APPEND )
{
bNext = HB_BLANK_AUTOINC;
break;
}
else if( iType == HB_BLANK_ROLLBACK )
{
bNext = HB_BLANK_SKIP;
break;
}
}
bNext = ' ';
break;
case HB_FT_AUTOINC:
if( iType == HB_BLANK_APPEND )
bNext = HB_BLANK_AUTOINC;
else if( iType == HB_BLANK_ROLLBACK )
bNext = HB_BLANK_SKIP;
else
bNext = '\0';
break;
case HB_FT_INTEGER:
case HB_FT_DOUBLE:
if( pField->uiFlags & HB_FF_AUTOINC )
{
if( iType == HB_BLANK_APPEND )
{
bNext = HB_BLANK_AUTOINC;
break;
}
else if( iType == HB_BLANK_ROLLBACK )
{
bNext = HB_BLANK_SKIP;
break;
}
}
bNext = '\0';
break;
default:
bNext = '\0';
break;
}
if( bNext == bFill )
{
ulSize += uiLen;
}
else
{
memset( pPtr, bFill, ulSize );
pPtr += ulSize;
ulSize = 0;
if( bNext == HB_BLANK_SKIP )
{
pPtr += uiLen;
}
else if( bNext == HB_BLANK_AUTOINC )
{
HB_LONG nValue = hb_dbfGetNextValue( pArea, uiCount );
if( pField->uiDec )
nValue = ( HB_LONG ) hb_numDecConv( ( double ) nValue, - ( int ) pField->uiDec );
if( pField->uiType == HB_FT_INTEGER ||
pField->uiType == HB_FT_AUTOINC )
{
if( uiLen == 1 )
*pPtr = ( signed char ) nValue;
else if( uiLen == 2 )
HB_PUT_LE_UINT16( pPtr, nValue );
else if( uiLen == 3 )
HB_PUT_LE_UINT24( pPtr, nValue );
else if( uiLen == 4 )
HB_PUT_LE_UINT32( pPtr, nValue );
else if( uiLen == 8 )
HB_PUT_LE_UINT64( pPtr, nValue );
}
else if( pField->uiType == HB_FT_DOUBLE )
{
HB_PUT_LE_DOUBLE( pPtr, nValue );
}
else
{
USHORT ui = uiLen;
do
{
pPtr[ --ui ] = ( BYTE ) nValue % 10 + '0';
nValue /= 10;
}
while( ui && nValue >= 1 );
}
pPtr += uiLen;
}
else
{
ulSize = uiLen;
bFill = bNext;
}
}
}
memset( pPtr, bFill, ulSize );
ulSize = pArea->pRecord - pPtr - ulSize;
if( ulSize < ( ULONG ) pArea->uiRecordLen )
memset( pPtr, '\0', ( ULONG ) pArea->uiRecordLen - ulSize );
}
| dbf1.c | 273 |
| STATIC BOOL | hb_dbfTriggerDo( DBFAREAP pArea, int iEvent, int iField, PHB_ITEM pItem )
static BOOL hb_dbfTriggerDo( DBFAREAP pArea, int iEvent,
int iField, PHB_ITEM pItem )
{
BOOL fResult = TRUE;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfTriggerDo(%p,%d,%d,%p)", pArea, iEvent, iField, pItem));
if( hb_vmRequestQuery() == 0 )
{
if( hb_vmRequestReenter() )
{
hb_vmPushDynSym( pArea->pTriggerSym );
hb_vmPushNil();
/* nEvent */
hb_vmPushInteger( iEvent );
/* nArea */
hb_vmPushInteger( pArea->uiArea );
/* nFieldPos (GET/PUT) */
hb_vmPushInteger( iField );
/* xTrigVal (PREUSE/GET/PUT) */
if( pItem )
{
#ifdef HB_TRIGVAR_BYREF
hb_vmPushItemRef( pItem );
#else
hb_vmPush( pItem );
#endif
hb_vmDo( 4 );
}
else
{
/* SIx3 makes: hb_vmPushInteger( 0 ); */
hb_vmDo( 3 );
}
fResult = hb_parl( -1 );
hb_vmRequestRestore();
}
}
return fResult;
}
| dbf1.c | 414 |
| STATIC VOID | hb_dbfTriggerSet( DBFAREAP pArea, PHB_ITEM pTrigger )
static void hb_dbfTriggerSet( DBFAREAP pArea, PHB_ITEM pTrigger )
{
char * szName;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfTriggerSet(%p,%p)", pArea, pTrigger));
szName = hb_itemGetCPtr( pTrigger );
pArea->pTriggerSym = *szName ? hb_dynsymFindName( szName ) : NULL;
if( pArea->pTriggerSym && !hb_dynsymIsFunction( pArea->pTriggerSym ) )
pArea->pTriggerSym = NULL;
pArea->fTrigger = pArea->pTriggerSym != NULL;
}
| dbf1.c | 459 |
| STATIC ULONG | hb_dbfCalcRecCount( DBFAREAP pArea )
static ULONG hb_dbfCalcRecCount( DBFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfCalcRecCount(%p)", pArea));
if( ! pArea->pDataFile )
return 0;
else
return ( ULONG ) ( ( hb_fileSize( pArea->pDataFile ) -
pArea->uiHeaderLen ) / pArea->uiRecordLen );
}
| dbf1.c | 475 |
| STATIC BOOL | hb_dbfReadRecord( DBFAREAP pArea )
static BOOL hb_dbfReadRecord( DBFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfReadRecord(%p)", pArea));
if( !pArea->fPositioned )
{
pArea->fValidBuffer = TRUE;
return TRUE;
}
if( pArea->ulRecNo > pArea->ulRecCount )
{
/* Update record count */
if( pArea->fShared )
pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
if( pArea->ulRecNo > pArea->ulRecCount )
{
pArea->fEof = pArea->fValidBuffer = TRUE;
return TRUE;
}
}
/* Read data from file */
if( hb_fileReadAt( pArea->pDataFile, pArea->pRecord, pArea->uiRecordLen,
( HB_FOFFSET ) pArea->uiHeaderLen +
( HB_FOFFSET ) ( pArea->ulRecNo - 1 ) *
( HB_FOFFSET ) pArea->uiRecordLen ) !=
( ULONG ) pArea->uiRecordLen )
{
PHB_ITEM pError = hb_errNew();
hb_errPutGenCode( pError, EG_READ );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_READ ) );
hb_errPutSubCode( pError, EDBF_READ );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutFileName( pError, pArea->szDataFileName );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FALSE;
}
if( SELF_GETREC( ( AREAP ) pArea, NULL ) == FAILURE )
return FALSE;
/* Set flags */
pArea->fValidBuffer = pArea->fPositioned = TRUE;
pArea->fDeleted = pArea->pRecord[ 0 ] == '*';
return TRUE;
}
| dbf1.c | 489 |
| STATIC BOOL | hb_dbfWriteRecord( DBFAREAP pArea )
static BOOL hb_dbfWriteRecord( DBFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfWriteRecord(%p)", pArea));
if( SELF_PUTREC( ( AREAP ) pArea, NULL ) == FAILURE )
return FALSE;
pArea->fRecordChanged = FALSE;
pArea->fDataFlush = TRUE;
return TRUE;
}
| dbf1.c | 543 |
| STATIC BOOL | hb_dbfPasswordSet( DBFAREAP pArea, PHB_ITEM pPasswd, BOOL fRaw )
static BOOL hb_dbfPasswordSet( DBFAREAP pArea, PHB_ITEM pPasswd, BOOL fRaw )
{
BYTE byBuffer[ 8 ];
ULONG ulLen;
BOOL fKeySet = FALSE, fSet;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfPasswordSet(%p,%p,%d)", pArea, pPasswd, fRaw));
ulLen = hb_itemGetCLen( pPasswd );
fSet = !pArea->fHasMemo && HB_IS_STRING( pPasswd ) && (!fRaw || ulLen == 8);
if( fSet )
{
ulLen = hb_itemGetCLen( pPasswd );
if( ulLen > 0 )
{
if( ulLen < 8 )
{
memcpy( byBuffer, hb_itemGetCPtr( pPasswd ), ulLen );
memset( byBuffer + ulLen, '\0', 8 - ulLen );
}
else
memcpy( byBuffer, hb_itemGetCPtr( pPasswd ), 8 );
}
}
if( pArea->pCryptKey )
hb_itemPutCL( pPasswd, ( char * ) pArea->pCryptKey, 8 );
else
hb_itemClear( pPasswd );
if( fSet )
{
if( pArea->pRecord && pArea->fPositioned )
{
SELF_GOCOLD( ( AREAP ) pArea );
pArea->fValidBuffer = FALSE;
}
if( pArea->pCryptKey )
{
/* clean the memory with password key - though it's not
* a serious actions in such case ;-)
*/
memset( pArea->pCryptKey, '\0', 8 );
hb_xfree( pArea->pCryptKey );
pArea->pCryptKey = NULL;
}
if( ulLen > 0 )
{
/* at this moment only one encryption method is used,
I'll add other later, [druzus] */
pArea->bCryptType = DB_CRYPT_SIX;
pArea->pCryptKey = ( BYTE * ) hb_xgrab( 8 );
/* SIX encode the key with its own value before use */
if( !fRaw )
hb_sxEnCrypt( byBuffer, pArea->pCryptKey, byBuffer, 8 );
else
memcpy( pArea->pCryptKey, byBuffer, 8 );
fKeySet = TRUE;
}
}
return fKeySet;
}
| dbf1.c | 558 |
| STATIC VOID | hb_dbfTableCrypt( DBFAREAP pArea, PHB_ITEM pPasswd, BOOL fEncrypt )
static void hb_dbfTableCrypt( DBFAREAP pArea, PHB_ITEM pPasswd, BOOL fEncrypt )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfTableCrypt(%p,%p,%d)", pArea, pPasswd, fEncrypt));
if( !pArea->fReadonly && !pArea->fShared &&
fEncrypt ? !pArea->fTableEncrypted && !pArea->fHasMemo :
pArea->fTableEncrypted )
{
ULONG ulRecords, ulRecNo;
if( SELF_RECCOUNT( ( AREAP ) pArea, &ulRecords ) == SUCCESS )
{
ERRCODE errCode = SUCCESS;
BYTE * pOldCryptKey, * pNewCryptKey;
pOldCryptKey = pArea->pCryptKey;
pArea->pCryptKey = NULL;
hb_dbfPasswordSet( pArea, pPasswd, FALSE );
pNewCryptKey = pArea->pCryptKey;
if( !fEncrypt && pNewCryptKey )
{
if( pOldCryptKey )
hb_xfree( pNewCryptKey );
else
pOldCryptKey = pNewCryptKey;
pNewCryptKey = NULL;
}
for( ulRecNo = 1; ulRecNo <= ulRecords; ++ulRecNo )
{
pArea->pCryptKey = pOldCryptKey;
errCode = SELF_GOTO( ( AREAP ) pArea, ulRecNo );
if( errCode != SUCCESS )
break;
if( !hb_dbfReadRecord( pArea ) )
{
errCode = FAILURE;
break;
}
pArea->pCryptKey = pNewCryptKey;
/* Buffer is hot? */
if( !pArea->fRecordChanged )
{
errCode = SELF_GOHOT( ( AREAP ) pArea );
if( errCode != SUCCESS )
break;
}
/* Force record encryption/decryption */
pArea->fEncrypted = fEncrypt;
/* Save encrypted record */
errCode = SELF_GOCOLD( ( AREAP ) pArea );
if( errCode != SUCCESS )
break;
}
pArea->pCryptKey = pNewCryptKey;
if( pOldCryptKey )
hb_xfree( pOldCryptKey );
if( errCode == SUCCESS )
{
pArea->fTableEncrypted = fEncrypt;
pArea->fUpdateHeader = TRUE;
SELF_WRITEDBHEADER( ( AREAP ) pArea );
}
}
}
}
| dbf1.c | 627 |
| STATIC ERRCODE | hb_dbfUnlockAllRecords( DBFAREAP pArea )
static ERRCODE hb_dbfUnlockAllRecords( DBFAREAP pArea )
{
ERRCODE uiError = SUCCESS;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfUnlockAllRecords(%p, %p)", pArea ));
if( pArea->pLocksPos )
{
ULONG ulCount;
uiError = SELF_GOCOLD( ( AREAP ) pArea );
for( ulCount = 0; ulCount < pArea->ulNumLocksPos; ulCount++ )
SELF_RAWLOCK( ( AREAP ) pArea, REC_UNLOCK, pArea->pLocksPos[ ulCount ] );
hb_xfree( pArea->pLocksPos );
pArea->pLocksPos = NULL;
}
pArea->ulNumLocksPos = 0;
return uiError;
}
| dbf1.c | 696 |
| STATIC ERRCODE | hb_dbfUnlockRecord( DBFAREAP pArea, ULONG ulRecNo )
static ERRCODE hb_dbfUnlockRecord( DBFAREAP pArea, ULONG ulRecNo )
{
ERRCODE uiError = SUCCESS;
ULONG ulCount, * pList;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfUnlockRecord(%p, %lu)", pArea, ulRecNo));
/* Search the locked record */
for( ulCount = 0; ulCount < pArea->ulNumLocksPos &&
pArea->pLocksPos[ ulCount ] != ulRecNo; ulCount++ ) {}
if( ulCount < pArea->ulNumLocksPos )
{
uiError = SELF_GOCOLD( ( AREAP ) pArea );
SELF_RAWLOCK( ( AREAP ) pArea, REC_UNLOCK, ulRecNo );
if( pArea->ulNumLocksPos == 1 ) /* Delete the list */
{
hb_xfree( pArea->pLocksPos );
pArea->pLocksPos = NULL;
pArea->ulNumLocksPos = 0;
}
else /* Resize the list */
{
pList = pArea->pLocksPos + ulCount;
memmove( pList, pList + 1, ( pArea->ulNumLocksPos - ulCount - 1 ) *
sizeof( ULONG ) );
pArea->pLocksPos = ( ULONG * ) hb_xrealloc( pArea->pLocksPos,
( pArea->ulNumLocksPos - 1 ) *
sizeof( ULONG ) );
pArea->ulNumLocksPos --;
}
}
return uiError;
}
| dbf1.c | 719 |
| STATIC ERRCODE | hb_dbfLockRecord( DBFAREAP pArea, ULONG ulRecNo, BOOL * pResult, BOOL bExclusive )
static ERRCODE hb_dbfLockRecord( DBFAREAP pArea, ULONG ulRecNo, BOOL * pResult,
BOOL bExclusive )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfLockRecord(%p, %lu, %p, %i)", pArea, ulRecNo,
pResult, (int) bExclusive));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
if( pArea->fFLocked )
{
* pResult = TRUE;
return SUCCESS;
}
if( ulRecNo == 0 )
ulRecNo = pArea->ulRecNo;
if( bExclusive )
{
hb_dbfUnlockAllRecords( pArea );
}
else if( pArea->ulNumLocksPos > 0 )
{
ULONG ul;
for( ul = 0; ul < pArea->ulNumLocksPos; ul++ )
{
if( pArea->pLocksPos[ ul ] == ulRecNo )
{
* pResult = TRUE;
return SUCCESS;
}
}
}
if( SELF_RAWLOCK( ( AREAP ) pArea, REC_LOCK, ulRecNo ) == SUCCESS )
{
if( pArea->ulNumLocksPos == 0 ) /* Create the list */
{
pArea->pLocksPos = ( ULONG * ) hb_xgrab( sizeof( ULONG ) );
}
else /* Resize the list */
{
pArea->pLocksPos = ( ULONG * ) hb_xrealloc( pArea->pLocksPos,
( pArea->ulNumLocksPos + 1 ) *
sizeof( ULONG ) );
}
pArea->pLocksPos[ pArea->ulNumLocksPos++ ] = ulRecNo;
* pResult = TRUE;
if( ulRecNo == pArea->ulRecNo )
{
if( !pArea->fPositioned )
{
if( SELF_GOTO( ( AREAP ) pArea, pArea->ulRecNo ) != SUCCESS )
return FAILURE;
}
else if( !pArea->fRecordChanged )
{
if( SELF_GOCOLD( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
pArea->fValidBuffer = FALSE;
}
}
}
else
* pResult = FALSE;
return SUCCESS;
}
| dbf1.c | 757 |
| STATIC ERRCODE | hb_dbfLockFile( DBFAREAP pArea, BOOL * pResult )
static ERRCODE hb_dbfLockFile( DBFAREAP pArea, BOOL * pResult )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfLockFile(%p, %p)", pArea, pResult));
if( !pArea->fFLocked )
{
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
hb_dbfUnlockAllRecords( pArea );
SELF_RAWLOCK( ( AREAP ) pArea, FILE_LOCK, 0 );
* pResult = pArea->fFLocked;
if( !pArea->fPositioned )
{
SELF_GOTO( ( AREAP ) pArea, pArea->ulRecNo );
}
else if( !pArea->fRecordChanged )
{
SELF_GOCOLD( ( AREAP ) pArea );
pArea->fValidBuffer = FALSE;
}
}
else
* pResult = TRUE;
return SUCCESS;
}
| dbf1.c | 832 |
| STATIC ERRCODE | hb_dbfUnlockFile( DBFAREAP pArea )
static ERRCODE hb_dbfUnlockFile( DBFAREAP pArea )
{
ERRCODE uiError = SUCCESS;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfUnlockFile(%p)", pArea));
if( pArea->fFLocked )
{
uiError = SELF_GOCOLD( ( AREAP ) pArea );
SELF_RAWLOCK( ( AREAP ) pArea, FILE_UNLOCK, 0 );
}
return uiError;
}
| dbf1.c | 868 |
| STATIC BOOL | hb_dbfIsLocked( DBFAREAP pArea, ULONG ulRecNo )
static BOOL hb_dbfIsLocked( DBFAREAP pArea, ULONG ulRecNo )
{
ULONG ulCount;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfIsLocked(%p)", pArea));
ulCount = pArea->ulNumLocksPos;
while( ulCount > 0 )
{
if( pArea->pLocksPos[ ulCount - 1 ] == ulRecNo )
return TRUE;
ulCount --;
}
return FALSE;
}
| dbf1.c | 885 |
| STATIC VOID | hb_dbfGetLockArray( DBFAREAP pArea, PHB_ITEM pItem )
static void hb_dbfGetLockArray( DBFAREAP pArea, PHB_ITEM pItem )
{
ULONG ulCount;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetLockArray(%p, %p)", pArea, pItem));
hb_arrayNew( pItem, pArea->ulNumLocksPos );
for( ulCount = 0; ulCount < pArea->ulNumLocksPos; ulCount++ )
{
hb_arraySetNL( pItem, ulCount + 1, pArea->pLocksPos[ ulCount ] );
}
}
| dbf1.c | 905 |
| HB_EXPORT ERRCODE | hb_dbfGetEGcode( ERRCODE errCode )
HB_EXPORT ERRCODE hb_dbfGetEGcode( ERRCODE errCode )
{
ERRCODE errEGcode;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetEGcode(%hu)", errCode));
switch( errCode )
{
case EDBF_OPEN_DBF:
errEGcode = EG_OPEN;
break;
case EDBF_CREATE_DBF:
errEGcode = EG_CREATE;
break;
case EDBF_READ:
errEGcode = EG_READ;
break;
case EDBF_WRITE:
errEGcode = EG_WRITE;
break;
case EDBF_CORRUPT:
errEGcode = EG_CORRUPTION;
break;
case EDBF_DATATYPE:
errEGcode = EG_DATATYPE;
break;
case EDBF_DATAWIDTH:
errEGcode = EG_DATAWIDTH;
break;
case EDBF_UNLOCKED:
errEGcode = EG_UNLOCKED;
break;
case EDBF_SHARED:
errEGcode = EG_SHARED;
break;
case EDBF_APPENDLOCK:
errEGcode = EG_APPENDLOCK;
break;
case EDBF_READONLY:
errEGcode = EG_READONLY;
break;
case EDBF_LOCK:
errEGcode = EG_LOCK;
break;
case EDBF_INVALIDKEY:
default:
errEGcode = EG_UNSUPPORTED;
break;
}
return errEGcode;
}
| dbf1.c | 922 |
| HB_EXPORT ULONG | hb_dbfGetMemoBlock( DBFAREAP pArea, USHORT uiIndex )
HB_EXPORT ULONG hb_dbfGetMemoBlock( DBFAREAP pArea, USHORT uiIndex )
{
ULONG ulBlock= 0;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetMemoBlock(%p, %hu)", pArea, uiIndex));
if( pArea->lpFields[ uiIndex ].uiLen == 4 )
{
ulBlock = HB_GET_LE_UINT32( &pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] );
}
else
{
USHORT uiCount;
BYTE bByte;
for( uiCount = 0; uiCount < 10; uiCount++ )
{
bByte = pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + uiCount ];
if( bByte >= '0' && bByte <= '9' )
{
ulBlock = ulBlock * 10 + ( bByte - '0' );
}
}
}
return ulBlock;
}
| dbf1.c | 980 |
| HB_EXPORT VOID | hb_dbfPutMemoBlock( DBFAREAP pArea, USHORT uiIndex, ULONG ulBlock )
HB_EXPORT void hb_dbfPutMemoBlock( DBFAREAP pArea, USHORT uiIndex, ULONG ulBlock )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfPutMemoBlock(%p, %hu, %lu)", pArea, uiIndex, ulBlock));
if( pArea->lpFields[ uiIndex ].uiLen == 4 )
{
HB_PUT_LE_UINT32( &pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ], ulBlock );
}
else
{
SHORT iCount;
for( iCount = 9; iCount >= 0; iCount-- )
{
if( ulBlock > 0 )
{
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + iCount ] = ( BYTE )( ulBlock % 10 ) + '0';
ulBlock /= 10;
}
else
{
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + iCount ] = ' ';
}
}
}
}
| dbf1.c | 1013 |
| HB_EXPORT ERRCODE | hb_dbfGetMemoData( DBFAREAP pArea, USHORT uiIndex, ULONG * pulBlock, ULONG * pulSize, ULONG * pulType )
HB_EXPORT ERRCODE hb_dbfGetMemoData( DBFAREAP pArea, USHORT uiIndex,
ULONG * pulBlock, ULONG * pulSize,
ULONG * pulType )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetMemoData(%p, %hu, %p, %p, %p)", pArea, uiIndex, pulBlock, pulSize, pulType));
*pulBlock = *pulSize = *pulType = 0;
if( uiIndex >= pArea->uiFieldCount ||
( pArea->lpFields[ uiIndex ].uiType != HB_FT_MEMO &&
pArea->lpFields[ uiIndex ].uiType != HB_FT_IMAGE &&
pArea->lpFields[ uiIndex ].uiType != HB_FT_BLOB &&
pArea->lpFields[ uiIndex ].uiType != HB_FT_OLE ) )
return FAILURE;
if( pArea->lpFields[ uiIndex ].uiLen == 4 )
{
*pulBlock = HB_GET_LE_UINT32( &pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] );
return SUCCESS;
}
else if( pArea->lpFields[ uiIndex ].uiLen == 10 )
{
ULONG ulValue;
if( pArea->bMemoType == DB_MEMO_SMT )
{
LPSMTFIELD pSMTFiled = ( LPSMTFIELD ) &pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ];
ulValue = HB_GET_LE_UINT16( pSMTFiled->type );
if( ulValue != 0x2020 )
{
*pulType = ulValue;
*pulSize = HB_GET_LE_UINT32( pSMTFiled->length );
*pulBlock = HB_GET_LE_UINT32( pSMTFiled->block );
}
}
/*
* check for NULL fields created by Access, they have chr(0) set
* in the whole memo block address, [druzus]
*/
else if( pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] != 0 )
{
USHORT uiCount;
BYTE bByte;
ulValue = 0;
for( uiCount = 0; uiCount < 10; uiCount++ )
{
bByte = pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + uiCount ];
if( bByte >= '0' && bByte <= '9' )
ulValue = ulValue * 10 + ( bByte - '0' );
else if( bByte != ' ' || ulValue )
{
PHB_ITEM pError = hb_errNew();
ERRCODE uiError;
hb_errPutGenCode( pError, EG_CORRUPTION );
hb_errPutSubCode( pError, EDBF_CORRUPT );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CORRUPTION ) );
hb_errPutFileName( pError, pArea->szDataFileName );
hb_errPutFlags( pError, EF_CANDEFAULT );
uiError = SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return uiError == E_DEFAULT ? SUCCESS : FAILURE;
}
}
*pulBlock = ulValue;
}
return SUCCESS;
}
return FAILURE;
}
| dbf1.c | 1045 |
| HB_EXPORT ERRCODE | hb_dbfSetMemoData( DBFAREAP pArea, USHORT uiIndex, ULONG ulBlock, ULONG ulSize, ULONG ulType )
HB_EXPORT ERRCODE hb_dbfSetMemoData( DBFAREAP pArea, USHORT uiIndex,
ULONG ulBlock, ULONG ulSize, ULONG ulType )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfSetMemoData(%p, %hu, %lu, %lu, %lu)", pArea, uiIndex, ulBlock, ulSize, ulType));
if( uiIndex >= pArea->uiFieldCount ||
( pArea->lpFields[ uiIndex ].uiType != HB_FT_MEMO &&
pArea->lpFields[ uiIndex ].uiType != HB_FT_IMAGE &&
pArea->lpFields[ uiIndex ].uiType != HB_FT_BLOB &&
pArea->lpFields[ uiIndex ].uiType != HB_FT_OLE ) )
return FAILURE;
if( pArea->lpFields[ uiIndex ].uiLen == 4 )
{
HB_PUT_LE_UINT32( &pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ], ulBlock );
return SUCCESS;
}
else if( pArea->lpFields[ uiIndex ].uiLen == 10 )
{
if( pArea->bMemoType == DB_MEMO_SMT )
{
LPSMTFIELD pSMTFiled = ( LPSMTFIELD ) &pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ];
HB_PUT_LE_UINT16( pSMTFiled->type, ulType );
HB_PUT_LE_UINT32( pSMTFiled->length, ulSize );
HB_PUT_LE_UINT32( pSMTFiled->block, ulBlock );
}
else
{
SHORT iCount;
for( iCount = 9; iCount >= 0; iCount-- )
{
if( ulBlock > 0 )
{
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + iCount ] = ( BYTE )( ulBlock % 10 ) + '0';
ulBlock /= 10;
}
else
{
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + iCount ] = ' ';
}
}
}
return SUCCESS;
}
return FAILURE;
}
| dbf1.c | 1125 |
| HB_EXPORT BOOL | hb_dbfLockIdxGetData( BYTE bScheme, HB_FOFFSET *ulPos, HB_FOFFSET *ulPool )
HB_EXPORT BOOL hb_dbfLockIdxGetData( BYTE bScheme, HB_FOFFSET *ulPos, HB_FOFFSET *ulPool )
{
switch( bScheme )
{
case DB_DBFLOCK_CLIP:
*ulPos = IDX_LOCKPOS_CLIP;
*ulPool = IDX_LOCKPOOL_CLIP;
break;
case DB_DBFLOCK_CL53:
*ulPos = IDX_LOCKPOS_CL53;
*ulPool = IDX_LOCKPOOL_CL53;
break;
case DB_DBFLOCK_CL53EXT:
*ulPos = IDX_LOCKPOS_CL53EXT;
*ulPool = IDX_LOCKPOOL_CL53EXT;
break;
case DB_DBFLOCK_VFP:
*ulPos = IDX_LOCKPOS_VFP;
*ulPool = IDX_LOCKPOOL_VFP;
break;
#ifndef HB_LONG_LONG_OFF
case DB_DBFLOCK_XHB64:
*ulPos = IDX_LOCKPOS_XHB64;
*ulPool = IDX_LOCKPOOL_XHB64;
break;
#endif
default:
return FALSE;
}
return TRUE;
}
| dbf1.c | 1180 |
| HB_EXPORT BOOL | hb_dbfLockIdxFile( PHB_FILE pFile, BYTE bScheme, USHORT usMode, HB_FOFFSET *pPoolPos )
HB_EXPORT BOOL hb_dbfLockIdxFile( PHB_FILE pFile, BYTE bScheme, USHORT usMode, HB_FOFFSET *pPoolPos )
{
HB_FOFFSET ulPos, ulPool, ulSize = 1;
BOOL fRet = FALSE;
if( !hb_dbfLockIdxGetData( bScheme, &ulPos, &ulPool ) )
{
return fRet;
}
for( ;; )
{
switch( usMode & FL_MASK )
{
case FL_LOCK:
if( ulPool )
{
if( ( usMode & FLX_SHARED ) != 0 )
*pPoolPos = ( HB_FOFFSET ) ( hb_random_num() * ulPool ) + 1;
else
{
*pPoolPos = 0;
ulSize = ulPool + 1;
}
}
else
{
*pPoolPos = 0;
}
break;
case FL_UNLOCK:
if( ulPool )
{
if( ! *pPoolPos )
ulSize = ulPool + 1;
}
else
{
*pPoolPos = 0;
}
break;
default:
return FALSE;
}
fRet = hb_fileLock( pFile, ulPos + *pPoolPos, ulSize, usMode );
if( fRet || ( usMode & FLX_WAIT ) == 0 || ( usMode & FL_MASK ) != FL_LOCK )
break;
/* TODO: call special error handler (LOCKHANDLER) here if fWait */
hb_releaseCPU();
}
return fRet;
}
| dbf1.c | 1222 |
| STATIC ERRCODE | hb_dbfLockData( DBFAREAP pArea, HB_FOFFSET * ulPos, HB_FOFFSET * ulFlSize, HB_FOFFSET * ulRlSize, int * iDir )
static ERRCODE hb_dbfLockData( DBFAREAP pArea,
HB_FOFFSET * ulPos, HB_FOFFSET * ulFlSize,
HB_FOFFSET * ulRlSize, int * iDir )
{
switch( pArea->bLockType )
{
case DB_DBFLOCK_CLIP:
*ulPos = DBF_LOCKPOS_CLIP;
*iDir = DBF_LOCKDIR_CLIP;
*ulFlSize = DBF_FLCKSIZE_CLIP;
*ulRlSize = DBF_RLCKSIZE_CLIP;
break;
case DB_DBFLOCK_CL53:
*ulPos = DBF_LOCKPOS_CL53;
*iDir = DBF_LOCKDIR_CL53;
*ulFlSize = DBF_FLCKSIZE_CL53;
*ulRlSize = DBF_RLCKSIZE_CL53;
break;
case DB_DBFLOCK_CL53EXT:
*ulPos = DBF_LOCKPOS_CL53EXT;
*iDir = DBF_LOCKDIR_CL53EXT;
*ulFlSize = DBF_FLCKSIZE_CL53EXT;
*ulRlSize = DBF_RLCKSIZE_CL53EXT;
break;
case DB_DBFLOCK_VFP:
if( pArea->fHasTags )
{
*ulPos = DBF_LOCKPOS_VFPX;
*iDir = DBF_LOCKDIR_VFPX;
*ulFlSize = DBF_FLCKSIZE_VFPX;
*ulRlSize = DBF_RLCKSIZE_VFPX;
}
else
{
*ulPos = DBF_LOCKPOS_VFP;
*iDir = DBF_LOCKDIR_VFP;
*ulFlSize = DBF_FLCKSIZE_VFP;
*ulRlSize = DBF_RLCKSIZE_VFP;
}
break;
#ifndef HB_LONG_LONG_OFF
case DB_DBFLOCK_XHB64:
*ulPos = DBF_LOCKPOS_XHB64;
*iDir = DBF_LOCKDIR_XHB64;
*ulFlSize = DBF_FLCKSIZE_XHB64;
*ulRlSize = DBF_RLCKSIZE_XHB64;
break;
#endif
default:
*ulPos = *ulFlSize = *ulRlSize = 0;
*iDir = 0;
return FAILURE;
}
return SUCCESS;
}
| dbf1.c | 1283 |
| STATIC ERRCODE | hb_dbfBof( DBFAREAP pArea, BOOL * pBof )
static ERRCODE hb_dbfBof( DBFAREAP pArea, BOOL * pBof )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfBof(%p, %p)", pArea, pBof));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
* pBof = pArea->fBof;
return SUCCESS;
}
| dbf1.c | 1350 |
| STATIC ERRCODE | hb_dbfEof( DBFAREAP pArea, BOOL * pEof )
static ERRCODE hb_dbfEof( DBFAREAP pArea, BOOL * pEof )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfEof(%p, %p)", pArea, pEof));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
* pEof = pArea->fEof;
return SUCCESS;
}
| dbf1.c | 1367 |
| STATIC ERRCODE | hb_dbfFound( DBFAREAP pArea, BOOL * pFound )
static ERRCODE hb_dbfFound( DBFAREAP pArea, BOOL * pFound )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfFound(%p, %p)", pArea, pFound));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
* pFound = pArea->fFound;
return SUCCESS;
}
| dbf1.c | 1384 |
| STATIC ERRCODE | hb_dbfGoBottom( DBFAREAP pArea )
static ERRCODE hb_dbfGoBottom( DBFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGoBottom(%p)", pArea));
if( SELF_GOCOLD( ( AREAP ) pArea ) == FAILURE )
return FAILURE;
/* Update record count */
if( pArea->fShared )
pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
pArea->fTop = FALSE;
pArea->fBottom = TRUE;
if( SELF_GOTO( ( AREAP ) pArea, pArea->ulRecCount ) != SUCCESS )
return FAILURE;
return SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
}
| dbf1.c | 1401 |
| STATIC ERRCODE | hb_dbfGoTo( DBFAREAP pArea, ULONG ulRecNo )
static ERRCODE hb_dbfGoTo( DBFAREAP pArea, ULONG ulRecNo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGoTo(%p, %lu)", pArea, ulRecNo));
if( SELF_GOCOLD( ( AREAP ) pArea ) == FAILURE )
return FAILURE;
if( pArea->lpdbPendingRel )
{
if( pArea->lpdbPendingRel->isScoped )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
else /* Reset parent rel struct */
pArea->lpdbPendingRel = NULL;
}
/* Update record count */
if( ulRecNo > pArea->ulRecCount && pArea->fShared )
pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
if( ulRecNo <= pArea->ulRecCount && ulRecNo >= 1 )
{
pArea->ulRecNo = ulRecNo;
pArea->fBof = pArea->fEof = pArea->fValidBuffer = FALSE;
pArea->fPositioned = TRUE;
}
else /* Out of space */
{
pArea->ulRecNo = pArea->ulRecCount + 1;
pArea->fBof = pArea->fEof = pArea->fValidBuffer = TRUE;
pArea->fPositioned = pArea->fDeleted = pArea->fEncrypted = FALSE;
/* Clear record buffer */
hb_dbfSetBlankRecord( pArea, HB_BLANK_EOF );
}
pArea->fFound = FALSE;
/* Force relational movement in child WorkAreas */
if( pArea->lpdbRelations )
return SELF_SYNCCHILDREN( ( AREAP ) pArea );
else
return SUCCESS;
}
| dbf1.c | 1423 |
| STATIC ERRCODE | hb_dbfGoToId( DBFAREAP pArea, PHB_ITEM pItem )
static ERRCODE hb_dbfGoToId( DBFAREAP pArea, PHB_ITEM pItem )
{
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGoToId(%p, %p)", pArea, pItem));
if( HB_IS_NUMERIC( pItem ) )
return SELF_GOTO( ( AREAP ) pArea, hb_itemGetNL( pItem ) );
else
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_DATATYPE );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_DATATYPE ) );
hb_errPutSubCode( pError, EDBF_DATATYPE );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
}
| dbf1.c | 1472 |
| STATIC ERRCODE | hb_dbfGoTop( DBFAREAP pArea )
static ERRCODE hb_dbfGoTop( DBFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGoTop(%p)", pArea));
pArea->fTop = TRUE;
pArea->fBottom = FALSE;
if( SELF_GOTO( ( AREAP ) pArea, 1 ) == FAILURE )
return FAILURE;
return SELF_SKIPFILTER( ( AREAP ) pArea, 1 );
}
| dbf1.c | 1495 |
| STATIC ERRCODE | hb_dbfSkip( DBFAREAP pArea, LONG lToSkip )
static ERRCODE hb_dbfSkip( DBFAREAP pArea, LONG lToSkip )
{
ERRCODE uiError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfSkip(%p, %ld)", pArea, lToSkip));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
pArea->fTop = pArea->fBottom = FALSE;
if( lToSkip == 0 || pArea->dbfi.itmCobExpr || pArea->dbfi.fFilter ||
hb_setGetDeleted() )
return SUPER_SKIP( ( AREAP ) pArea, lToSkip );
uiError = SELF_SKIPRAW( ( AREAP ) pArea, lToSkip );
/* TODO: remove this hack - it's not necessary if SKIPRAW works
as it should, Druzus */
/* Move first record and set Bof flag */
if( uiError == SUCCESS && pArea->fBof && lToSkip < 0 )
{
uiError = SELF_GOTOP( ( AREAP ) pArea );
pArea->fBof = TRUE;
}
/* Update Bof and Eof flags */
if( lToSkip < 0 )
pArea->fEof = FALSE;
else /* if( lToSkip > 0 ) */
pArea->fBof = FALSE;
return uiError;
}
| dbf1.c | 1511 |
| STATIC ERRCODE | hb_dbfSkipRaw( DBFAREAP pArea, LONG lToSkip )
static ERRCODE hb_dbfSkipRaw( DBFAREAP pArea, LONG lToSkip )
{
ERRCODE uiError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfSkipRaw(%p, %ld)", pArea, lToSkip));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
if( lToSkip == 0 )
{
BOOL bBof, bEof;
/* Save flags */
bBof = pArea->fBof;
bEof = pArea->fEof;
uiError = SELF_GOTO( ( AREAP ) pArea, pArea->ulRecNo );
/* Restore flags */
pArea->fBof = bBof;
pArea->fEof = bEof;
}
else if( lToSkip < 0 && ( ULONG ) ( -lToSkip ) >= pArea->ulRecNo )
{
uiError = SELF_GOTO( ( AREAP ) pArea, 1 );
pArea->fBof = TRUE;
}
else
{
uiError = SELF_GOTO( ( AREAP ) pArea, pArea->ulRecNo + lToSkip );
}
return uiError;
}
| dbf1.c | 1553 |
| STATIC ERRCODE | hb_dbfAddField( DBFAREAP pArea, LPDBFIELDINFO pFieldInfo )
static ERRCODE hb_dbfAddField( DBFAREAP pArea, LPDBFIELDINFO pFieldInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfAddField(%p, %p)", pArea, pFieldInfo));
if( pArea->bMemoType == DB_MEMO_SMT &&
( pFieldInfo->uiType == HB_FT_MEMO ||
pFieldInfo->uiType == HB_FT_IMAGE ||
pFieldInfo->uiType == HB_FT_BLOB ||
pFieldInfo->uiType == HB_FT_OLE ) )
pFieldInfo->uiLen = 10;
/* Update field offset */
pArea->pFieldOffset[ pArea->uiFieldCount ] = pArea->uiRecordLen;
pArea->uiRecordLen += pFieldInfo->uiLen;
return SUPER_ADDFIELD( ( AREAP ) pArea, pFieldInfo );
}
| dbf1.c | 1595 |
| STATIC ERRCODE | hb_dbfAppend( DBFAREAP pArea, BOOL bUnLockAll )
static ERRCODE hb_dbfAppend( DBFAREAP pArea, BOOL bUnLockAll )
{
ULONG ulNewRecord;
PHB_ITEM pError;
BOOL bLocked;
ERRCODE uiError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfAppend(%p, %d)", pArea, (int) bUnLockAll));
if( SELF_GOCOLD( ( AREAP ) pArea ) == FAILURE )
return FAILURE;
if( pArea->fTrigger )
{
if( !hb_dbfTriggerDo( pArea, EVENT_APPEND, 0, NULL ) )
return FAILURE;
}
if( pArea->fReadonly )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_READONLY );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_READONLY ) );
hb_errPutSubCode( pError, EDBF_READONLY );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
if( pArea->lpdbPendingRel )
{
if( pArea->lpdbPendingRel->isScoped )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
else /* Reset parent rel struct */
pArea->lpdbPendingRel = NULL;
}
if( pArea->fShared )
{
bLocked = FALSE;
if( SELF_RAWLOCK( ( AREAP ) pArea, APPEND_LOCK, 0 ) == SUCCESS )
{
/* Update RecCount */
pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
ulNewRecord = pArea->ulRecCount + 1;
if( pArea->fFLocked || hb_dbfIsLocked( pArea, ulNewRecord ) )
bLocked = TRUE;
else if( hb_dbfLockRecord( pArea, ulNewRecord, &bLocked, bUnLockAll ) != SUCCESS )
{
if( bLocked )
hb_dbfUnlockRecord( pArea, ulNewRecord );
SELF_RAWLOCK( ( AREAP ) pArea, APPEND_UNLOCK, 0 );
return FAILURE;
}
}
if( !bLocked )
{
SELF_RAWLOCK( ( AREAP ) pArea, APPEND_UNLOCK, 0 );
pError = hb_errNew();
hb_errPutGenCode( pError, EG_APPENDLOCK );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_APPENDLOCK ) );
hb_errPutSubCode( pError, EDBF_APPENDLOCK );
hb_errPutFlags( pError, EF_CANDEFAULT );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
}
/* Clear record buffer and update pArea */
hb_dbfSetBlankRecord( pArea, HB_BLANK_APPEND );
pArea->fValidBuffer = pArea->fUpdateHeader = pArea->fRecordChanged =
pArea->fAppend = pArea->fPositioned = TRUE;
pArea->ulRecCount ++;
pArea->ulRecNo = pArea->ulRecCount;
pArea->fDeleted = pArea->fBof = pArea->fEof = pArea->fFound = FALSE;
pArea->fEncrypted = pArea->pCryptKey != NULL && !pArea->fHasMemo;
if( pArea->fShared )
{
uiError = SELF_GOCOLD( ( AREAP ) pArea );
SELF_RAWLOCK( ( AREAP ) pArea, APPEND_UNLOCK, 0 );
return uiError;
}
return SUCCESS;
}
| dbf1.c | 1615 |
| STATIC ERRCODE | hb_dbfDeleteRec( DBFAREAP pArea )
static ERRCODE hb_dbfDeleteRec( DBFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfDeleteRec(%p)", pArea));
if( pArea->fTrigger )
{
if( !hb_dbfTriggerDo( pArea, EVENT_DELETE, 0, NULL ) )
return FAILURE;
}
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
/* Read record */
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
return FAILURE;
if( !pArea->fPositioned )
return SUCCESS;
/* Buffer is hot? */
if( !pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == FAILURE )
return FAILURE;
pArea->pRecord[ 0 ] = '*';
pArea->fDeleted = TRUE;
return SUCCESS;
}
| dbf1.c | 1709 |
| STATIC ERRCODE | hb_dbfDeleted( DBFAREAP pArea, BOOL * pDeleted )
static ERRCODE hb_dbfDeleted( DBFAREAP pArea, BOOL * pDeleted )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfDeleted(%p, %p)", pArea, pDeleted));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
/* Read record */
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
return FAILURE;
* pDeleted = pArea->fDeleted;
return SUCCESS;
}
| dbf1.c | 1744 |
| STATIC ERRCODE | hb_dbfFlush( DBFAREAP pArea )
static ERRCODE hb_dbfFlush( DBFAREAP pArea )
{
ERRCODE uiError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfFlush(%p)", pArea));
uiError = SELF_GOCOLD( ( AREAP ) pArea );
if( uiError == SUCCESS )
{
if( pArea->fUpdateHeader )
uiError = SELF_WRITEDBHEADER( ( AREAP ) pArea );
}
if( hb_setGetHardCommit() && uiError == SUCCESS )
{
if( pArea->fDataFlush )
{
hb_fileCommit( pArea->pDataFile );
pArea->fDataFlush = FALSE;
}
if( pArea->fHasMemo && pArea->pMemoFile && pArea->fMemoFlush )
{
hb_fileCommit( pArea->pMemoFile );
pArea->fMemoFlush = FALSE;
}
}
return uiError;
}
| dbf1.c | 1765 |
| STATIC ERRCODE | hb_dbfGetRec( DBFAREAP pArea, BYTE ** pBuffer )
static ERRCODE hb_dbfGetRec( DBFAREAP pArea, BYTE ** pBuffer )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetRec(%p, %p)", pArea, pBuffer));
if( pBuffer != NULL )
{
/* Read record */
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
return FAILURE;
*pBuffer = pArea->pRecord;
}
else
{
if( pArea->pRecord[ 0 ] == 'D' || pArea->pRecord[ 0 ] == 'E' )
{
pArea->fEncrypted = TRUE;
pArea->pRecord[ 0 ] = pArea->pRecord[ 0 ] == 'D' ? '*' : ' ';
if( pArea->pCryptKey && pArea->bCryptType == DB_CRYPT_SIX )
{
hb_sxDeCrypt( pArea->pRecord + 1, pArea->pRecord + 1,
pArea->pCryptKey, pArea->uiRecordLen - 1 );
}
}
else
{
pArea->fEncrypted = FALSE;
}
}
return SUCCESS;
}
| dbf1.c | 1798 |
| STATIC ERRCODE | hb_dbfGetValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
static ERRCODE hb_dbfGetValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
LPFIELD pField;
BOOL fError;
PHB_ITEM pError;
char szBuffer[24];
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetValue(%p, %hu, %p)", pArea, uiIndex, pItem));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
/* Read record */
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
return FAILURE;
fError = FALSE;
uiIndex--;
pField = pArea->lpFields + uiIndex;
switch( pField->uiType )
{
case HB_FT_STRING:
#ifndef HB_CDP_SUPPORT_OFF
if( pArea->cdPage != hb_vmCDP() )
{
char * pVal = ( char * ) hb_xgrab( pField->uiLen + 1 );
memcpy( pVal, pArea->pRecord + pArea->pFieldOffset[ uiIndex ], pField->uiLen );
pVal[ pField->uiLen ] = '\0';
hb_cdpnTranslate( pVal, pArea->cdPage, hb_vmCDP(), pField->uiLen );
hb_itemPutCLPtr( pItem, pVal, pField->uiLen );
}
else
#endif
{
hb_itemPutCL( pItem, ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
pField->uiLen );
}
break;
case HB_FT_LOGICAL:
hb_itemPutL( pItem, pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] == 'T' ||
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] == 't' ||
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] == 'Y' ||
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] == 'y' );
break;
case HB_FT_DATE:
if( pField->uiLen == 3 )
{
hb_itemPutDL( pItem, HB_GET_LE_UINT24( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ) );
}
else if( pField->uiLen == 4 )
{
hb_itemPutDL( pItem, HB_GET_LE_UINT32( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ) );
}
else
{
hb_itemPutDS( pItem, ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ] );
}
break;
case HB_FT_TIME:
if( pField->uiLen == 4 )
{
hb_itemPutC( pItem, hb_timeStampStr( szBuffer,
HB_GET_LE_INT32( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ) ) );
break;
}
/* no break */
case HB_FT_MODTIME:
case HB_FT_DAYTIME:
hb_itemPutC( pItem, hb_dateTimeStampStr( szBuffer,
HB_GET_LE_INT32( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ),
HB_GET_LE_INT32( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + 4 ) ) );
break;
case HB_FT_INTEGER:
case HB_FT_CURRENCY:
case HB_FT_AUTOINC:
case HB_FT_ROWVER:
if( pField->uiDec )
{
double dValue;
int iLen;
switch( pField->uiLen )
{
case 1:
dValue = ( SCHAR ) pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ];
iLen = 4;
break;
case 2:
dValue = HB_GET_LE_INT16( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] );
iLen = 6;
break;
case 3:
dValue = HB_GET_LE_INT24( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] );
iLen = 10;
break;
case 4:
dValue = HB_GET_LE_INT32( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] );
iLen = 10;
break;
case 8:
dValue = ( double ) HB_GET_LE_INT64( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] );
iLen = 20;
break;
default:
dValue = 0;
iLen = 0;
fError = TRUE;
break;
}
hb_itemPutNDLen( pItem, hb_numDecConv( dValue, ( int ) pField->uiDec ),
iLen, ( int ) pField->uiDec );
}
else
{
switch( pField->uiLen )
{
case 1:
hb_itemPutNILen( pItem, ( SCHAR ) pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ], 4 );
break;
case 2:
hb_itemPutNILen( pItem, ( int ) HB_GET_LE_INT16( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ), 6 );
break;
case 3:
hb_itemPutNIntLen( pItem, ( HB_LONG ) HB_GET_LE_INT24( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ), 10 );
break;
case 4:
hb_itemPutNIntLen( pItem, ( HB_LONG ) HB_GET_LE_INT32( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ), 10 );
break;
case 8:
#ifndef HB_LONG_LONG_OFF
hb_itemPutNIntLen( pItem, ( HB_LONG ) HB_GET_LE_INT64( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ), 20 );
#else
hb_itemPutNLen( pItem, ( double ) HB_GET_LE_INT64( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ), 20, 0 );
#endif
break;
default:
fError = TRUE;
break;
}
}
break;
case HB_FT_DOUBLE:
case HB_FT_CURDOUBLE:
hb_itemPutNDLen( pItem, HB_GET_LE_DOUBLE( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ),
20 - ( pField->uiDec > 0 ? ( pField->uiDec + 1 ) : 0 ),
( int ) pField->uiDec );
break;
case HB_FT_LONG:
case HB_FT_FLOAT:
/* DBASE documentation defines maximum numeric field size as 20
* but Clipper allows to create longer fields so I remove this
* limit, Druzus
*/
/*
if( pField->uiLen > 20 )
fError = TRUE;
else
*/
{
HB_LONG lVal;
double dVal;
BOOL fDbl;
fDbl = hb_strnToNum( (const char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
pField->uiLen, &lVal, &dVal );
if( pField->uiDec )
{
hb_itemPutNDLen( pItem, fDbl ? dVal : ( double ) lVal,
( int ) ( pField->uiLen - pField->uiDec - 1 ),
( int ) pField->uiDec );
}
else if( fDbl )
{
hb_itemPutNDLen( pItem, dVal, ( int ) pField->uiLen, 0 );
}
else
{
hb_itemPutNIntLen( pItem, lVal, ( int ) pField->uiLen );
}
}
break;
case HB_FT_ANY:
if( pField->uiLen == 3 )
{
hb_itemPutDL( pItem, hb_sxPtoD( ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ) );
}
else if( pField->uiLen == 4 )
{
hb_itemPutNIntLen( pItem, ( HB_LONG ) HB_GET_LE_INT32( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ), 10 );
}
else
{
fError = TRUE;
}
break;
case HB_FT_MEMO:
default:
fError = TRUE;
break;
}
/* Any error? */
if( fError )
{
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_errPutSubCode( pError, EDBF_DATATYPE );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
if( pArea->fTrigger )
{
if( !hb_dbfTriggerDo( pArea, EVENT_GET, uiIndex + 1, pItem ) )
return FAILURE;
}
return SUCCESS;
}
| dbf1.c | 1833 |
| STATIC ERRCODE | hb_dbfGetVarLen( DBFAREAP pArea, USHORT uiIndex, ULONG * pLength )
static ERRCODE hb_dbfGetVarLen( DBFAREAP pArea, USHORT uiIndex, ULONG * pLength )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetVarLen(%p, %hu, %p)", pArea, uiIndex, pLength));
* pLength = pArea->lpFields[ uiIndex - 1 ].uiLen;
return SUCCESS;
}
| dbf1.c | 2071 |
| STATIC ERRCODE | hb_dbfGoCold( DBFAREAP pArea )
static ERRCODE hb_dbfGoCold( DBFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGoCold(%p)", pArea));
if( pArea->fRecordChanged )
{
if( pArea->fTrigger )
{
/* The pending relation may move the record pointer so we should
disable them for trigger evaluation */
LPDBRELINFO lpdbPendingRel = pArea->lpdbPendingRel;
pArea->lpdbPendingRel = NULL;
hb_dbfTriggerDo( pArea, EVENT_UPDATE, 0, NULL );
/* Restore disabled pending relation */
pArea->lpdbPendingRel = lpdbPendingRel;
}
if( pArea->fModStamp )
hb_dbfUpdateStampFields( pArea );
/* Write current record */
if( ! hb_dbfWriteRecord( pArea ) )
return FAILURE;
if( pArea->fAppend )
{
pArea->fUpdateHeader = TRUE;
pArea->fAppend = FALSE;
}
/* Update header */
if( pArea->fShared && pArea->fUpdateHeader )
return SELF_WRITEDBHEADER( ( AREAP ) pArea );
}
return SUCCESS;
}
| dbf1.c | 2083 |
| STATIC ERRCODE | hb_dbfGoHot( DBFAREAP pArea )
static ERRCODE hb_dbfGoHot( DBFAREAP pArea )
{
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGoHot(%p)", pArea));
if( pArea->fReadonly )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_READONLY );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_READONLY ) );
hb_errPutSubCode( pError, EDBF_READONLY );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
else if( pArea->fShared && !pArea->fFLocked &&
!hb_dbfIsLocked( pArea, pArea->ulRecNo ) )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_UNLOCKED );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_UNLOCKED ) );
hb_errPutSubCode( pError, EDBF_UNLOCKED );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
pArea->fRecordChanged = TRUE;
return SUCCESS;
}
| dbf1.c | 2125 |
| STATIC ERRCODE | hb_dbfPutRec( DBFAREAP pArea, BYTE * pBuffer )
static ERRCODE hb_dbfPutRec( DBFAREAP pArea, BYTE * pBuffer )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfPutRec(%p, %p)", pArea, pBuffer));
if( pBuffer != NULL )
{
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
if( !pArea->fPositioned )
return SUCCESS;
if( !pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
/* Copy data to buffer */
memcpy( pArea->pRecord, pBuffer, pArea->uiRecordLen );
/*
* TODO: such operation should be forbidden
* maybe it will be good to return FAILURE when
* pArea->pRecord[ 0 ] != '*' && pArea->pRecord[ 0 ] != ' '
*/
if( pArea->pRecord[ 0 ] == 'D' || pArea->pRecord[ 0 ] == 'E' )
{
if( !pArea->fHasMemo )
pArea->fEncrypted = TRUE;
pArea->pRecord[ 0 ] = pArea->pRecord[ 0 ] == 'D' ? '*' : ' ';
}
pArea->fDeleted = pArea->pRecord[ 0 ] == '*';
}
else /* if( pArea->fRecordChanged ) */
{
BYTE * pRecord = pArea->pRecord;
USHORT uiWritten;
if( pArea->pCryptKey )
{
/* This enables record encryption in update operation */
if( pArea->bCryptType == DB_CRYPT_SIX && !pArea->fHasMemo )
pArea->fEncrypted = TRUE;
if( pArea->bCryptType == DB_CRYPT_SIX && pArea->fEncrypted )
{
pRecord = ( BYTE * ) hb_xgrab( pArea->uiRecordLen );
pRecord[ 0 ] = pArea->fDeleted ? 'D' : 'E';
hb_sxEnCrypt( pArea->pRecord + 1, pRecord + 1, pArea->pCryptKey,
pArea->uiRecordLen - 1 );
}
}
/* Write data to file */
uiWritten = hb_fileWriteAt( pArea->pDataFile, pRecord, pArea->uiRecordLen,
( HB_FOFFSET ) pArea->uiHeaderLen +
( HB_FOFFSET ) ( pArea->ulRecNo - 1 ) *
( HB_FOFFSET ) pArea->uiRecordLen );
if( pRecord != pArea->pRecord )
hb_xfree( pRecord );
if( uiWritten != pArea->uiRecordLen )
{
PHB_ITEM pError = hb_errNew();
hb_errPutGenCode( pError, EG_WRITE );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_WRITE ) );
hb_errPutSubCode( pError, EDBF_WRITE );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutFileName( pError, pArea->szDataFileName );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
}
return SUCCESS;
}
| dbf1.c | 2159 |
| STATIC ERRCODE | hb_dbfPutValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
static ERRCODE hb_dbfPutValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
USHORT uiSize;
LPFIELD pField;
/* this buffer is for date and number conversion,
* DBASE documentation defines maximum numeric field size as 20
* but Clipper allows to create longer fields so I removed this
* limit [druzus]
*/
char szBuffer[ 256 ];
PHB_ITEM pError;
ERRCODE uiError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfPutValue(%p, %hu, %p)", pArea, uiIndex, pItem));
if( pArea->fTrigger )
{
if( !hb_dbfTriggerDo( pArea, EVENT_PUT, uiIndex, pItem ) )
return FAILURE;
}
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
/* Read record */
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
return FAILURE;
if( !pArea->fPositioned )
return SUCCESS;
/* Buffer is hot? */
if( !pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == FAILURE )
return FAILURE;
uiError = SUCCESS;
uiIndex--;
pField = pArea->lpFields + uiIndex;
if( pField->uiType == HB_FT_MEMO ||
pField->uiType == HB_FT_IMAGE ||
pField->uiType == HB_FT_BLOB ||
pField->uiType == HB_FT_OLE )
uiError = EDBF_DATATYPE;
else
{
if( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) )
{
if( pField->uiType == HB_FT_STRING )
{
uiSize = ( USHORT ) hb_itemGetCLen( pItem );
if( uiSize > pField->uiLen )
uiSize = pField->uiLen;
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
hb_itemGetCPtr( pItem ), uiSize );
#ifndef HB_CDP_SUPPORT_OFF
hb_cdpnTranslate( (char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_vmCDP(), pArea->cdPage, uiSize );
#endif
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + uiSize,
' ', pField->uiLen - uiSize );
}
else if( pField->uiType == HB_FT_DAYTIME )
{
LONG lJulian, lMillisec;
BYTE * ptr = pArea->pRecord + pArea->pFieldOffset[ uiIndex ];
hb_dateTimeStampStrGet( hb_itemGetCPtr( pItem ), &lJulian, &lMillisec );
HB_PUT_LE_UINT32( ptr, lJulian );
ptr += 4;
HB_PUT_LE_UINT32( ptr, lMillisec );
}
else
uiError = EDBF_DATATYPE;
}
/* Must precede HB_IS_NUMERIC() because a DATE is also a NUMERIC. (xHarbour) */
else if( HB_IS_DATE( pItem ) )
{
if( pField->uiType == HB_FT_DATE )
{
if( pField->uiLen == 3 )
{
HB_PUT_LE_UINT24( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
hb_itemGetDL( pItem ) );
}
else if( pField->uiLen == 4 )
{
HB_PUT_LE_UINT32( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
hb_itemGetDL( pItem ) );
}
else
{
hb_itemGetDS( pItem, szBuffer );
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, 8 );
}
}
else if( pField->uiType == HB_FT_ANY && pField->uiLen == 3 )
{
hb_sxDtoP( ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
hb_itemGetDL( pItem ) );
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_NUMBER( pItem ) )
{
if( pField->uiType == HB_FT_LONG || pField->uiType == HB_FT_FLOAT )
{
if( hb_itemStrBuf( szBuffer, pItem, pField->uiLen, pField->uiDec ) )
{
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
szBuffer, pField->uiLen );
}
else
{
uiError = EDBF_DATAWIDTH;
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
'*', pField->uiLen );
}
}
else if( pField->uiType == HB_FT_INTEGER )
{
HB_LONG lVal;
double dVal;
int iSize;
if( pField->uiDec )
{
dVal = hb_numDecConv( hb_itemGetND( pItem ), - ( int ) pField->uiDec );
lVal = ( HB_LONG ) dVal;
if( ! HB_DBL_LIM_INT64( dVal ) )
iSize = 99;
else
#ifndef HB_LONG_LONG_OFF
iSize = HB_LIM_INT8( lVal ) ? 1 :
( HB_LIM_INT16( lVal ) ? 2 :
( HB_LIM_INT24( lVal ) ? 3 :
( HB_LIM_INT32( lVal ) ? 4 : 8 ) ) );
#else
iSize = HB_DBL_LIM_INT8( dVal ) ? 1 :
( HB_DBL_LIM_INT16( dVal ) ? 2 :
( HB_DBL_LIM_INT24( dVal ) ? 3 :
( HB_DBL_LIM_INT32( dVal ) ? 4 : 8 ) ) );
#endif
}
else if( HB_IS_DOUBLE( pItem ) )
{
dVal = hb_itemGetND( pItem );
lVal = ( HB_LONG ) dVal;
if( ! HB_DBL_LIM_INT64( dVal ) )
iSize = 99;
else
#ifndef HB_LONG_LONG_OFF
iSize = HB_LIM_INT8( lVal ) ? 1 :
( HB_LIM_INT16( lVal ) ? 2 :
( HB_LIM_INT24( lVal ) ? 3 :
( HB_LIM_INT32( lVal ) ? 4 : 8 ) ) );
#else
iSize = HB_DBL_LIM_INT8( dVal ) ? 1 :
( HB_DBL_LIM_INT16( dVal ) ? 2 :
( HB_DBL_LIM_INT24( dVal ) ? 3 :
( HB_DBL_LIM_INT32( dVal ) ? 4 : 8 ) ) );
#endif
}
else
{
lVal = ( HB_LONG ) hb_itemGetNInt( pItem );
#ifdef HB_LONG_LONG_OFF
dVal = ( double ) lVal;
#endif
iSize = HB_LIM_INT8( lVal ) ? 1 :
( HB_LIM_INT16( lVal ) ? 2 :
( HB_LIM_INT24( lVal ) ? 3 :
( HB_LIM_INT32( lVal ) ? 4 : 8 ) ) );
}
if( iSize > pField->uiLen )
{
uiError = EDBF_DATAWIDTH;
}
else
{
switch( pField->uiLen )
{
case 1:
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] = ( signed char ) lVal;
break;
case 2:
HB_PUT_LE_UINT16( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], ( UINT16 ) lVal );
break;
case 3:
HB_PUT_LE_UINT24( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], ( UINT32 ) lVal );
break;
case 4:
HB_PUT_LE_UINT32( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], ( UINT32 ) lVal );
break;
case 8:
#ifndef HB_LONG_LONG_OFF
HB_PUT_LE_UINT64( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], ( UINT64 ) lVal );
#else
HB_PUT_LE_UINT64( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], dVal );
#endif
break;
default:
uiError = EDBF_DATATYPE;
break;
}
}
}
else if( pField->uiType == HB_FT_DOUBLE )
{
HB_PUT_LE_DOUBLE( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_itemGetND( pItem ) );
}
else if( pField->uiType == HB_FT_ANY && pField->uiLen == 4 )
{
HB_LONG lVal = hb_itemGetNInt( pItem );
if( HB_IS_DOUBLE( pItem ) ?
HB_DBL_LIM_INT32( hb_itemGetND( pItem ) ) :
HB_LIM_INT32( lVal ) )
{
HB_PUT_LE_UINT32( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], ( UINT32 ) lVal );
}
else
{
uiError = EDBF_DATAWIDTH;
}
}
else
{
uiError = EDBF_DATATYPE;
}
}
else if( HB_IS_LOGICAL( pItem ) )
{
if( pField->uiType == HB_FT_LOGICAL )
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] = hb_itemGetL( pItem ) ? 'T' : 'F';
else
uiError = EDBF_DATATYPE;
}
else
uiError = EDBF_DATATYPE;
}
/* Exit if any error */
if( uiError != SUCCESS )
{
pError = hb_errNew();
hb_errPutGenCode( pError, hb_dbfGetEGcode( uiError ) );
hb_errPutDescription( pError, hb_langDGetErrorDesc( hb_dbfGetEGcode( uiError ) ) );
hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) );
hb_errPutSubCode( pError, uiError );
hb_errPutFlags( pError, EF_CANDEFAULT );
uiError = SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return uiError == E_DEFAULT ? SUCCESS : FAILURE;
}
return SUCCESS;
}
| dbf1.c | 2242 |
| STATIC ERRCODE | hb_dbfRecall( DBFAREAP pArea )
static ERRCODE hb_dbfRecall( DBFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfRecall(%p)", pArea));
if( pArea->fTrigger )
{
if( !hb_dbfTriggerDo( pArea, EVENT_RECALL, 0, NULL ) )
return FAILURE;
}
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
/* Read record */
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
return FAILURE;
if( !pArea->fPositioned )
return SUCCESS;
/* Buffer is hot? */
if( !pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
pArea->pRecord[ 0 ] = ' ';
pArea->fDeleted = FALSE;
return SUCCESS;
}
| dbf1.c | 2505 |
| STATIC ERRCODE | hb_dbfRecCount( DBFAREAP pArea, ULONG * pRecCount )
static ERRCODE hb_dbfRecCount( DBFAREAP pArea, ULONG * pRecCount )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfRecCount(%p, %p)", pArea, pRecCount));
/* Update record count */
if( pArea->fShared )
pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
* pRecCount = pArea->ulRecCount;
return SUCCESS;
}
| dbf1.c | 2540 |
| STATIC ERRCODE | hb_dbfRecNo( DBFAREAP pArea, ULONG * ulRecNo )
static ERRCODE hb_dbfRecNo( DBFAREAP pArea, ULONG * ulRecNo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfRecNo(%p, %p)", pArea, ulRecNo));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
*ulRecNo = pArea->ulRecNo;
return SUCCESS;
}
| dbf1.c | 2555 |
| STATIC ERRCODE | hb_dbfRecId( DBFAREAP pArea, PHB_ITEM pRecNo )
static ERRCODE hb_dbfRecId( DBFAREAP pArea, PHB_ITEM pRecNo )
{
ERRCODE errCode;
ULONG ulRecNo;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfRecId(%p, %p)", pArea, pRecNo));
errCode = SELF_RECNO( ( AREAP ) pArea, &ulRecNo );
#ifdef HB_C52_STRICT
/* this is for strict Clipper compatibility but IMHO Clipper should not
do that and always set fixed size independent to the record number */
if( ulRecNo < 10000000 )
{
hb_itemPutNLLen( pRecNo, ulRecNo, 7 );
}
else
{
hb_itemPutNLLen( pRecNo, ulRecNo, 10 );
}
#else
hb_itemPutNInt( pRecNo, ulRecNo );
#endif
return errCode;
}
| dbf1.c | 2572 |
| STATIC ERRCODE | hb_dbfSetFieldExtent( DBFAREAP pArea, USHORT uiFieldExtent )
static ERRCODE hb_dbfSetFieldExtent( DBFAREAP pArea, USHORT uiFieldExtent )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfSetFieldExtent(%p, %hu)", pArea, uiFieldExtent));
if( SUPER_SETFIELDEXTENT( ( AREAP ) pArea, uiFieldExtent ) == FAILURE )
return FAILURE;
/* Alloc field offsets array */
if( uiFieldExtent )
{
pArea->pFieldOffset = ( USHORT * ) hb_xgrab( uiFieldExtent * sizeof( USHORT ) );
memset( pArea->pFieldOffset, 0, uiFieldExtent * sizeof( USHORT ) );
}
return SUCCESS;
}
| dbf1.c | 2601 |
| STATIC ERRCODE | hb_dbfClose( DBFAREAP pArea )
static ERRCODE hb_dbfClose( DBFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfClose(%p)", pArea));
if( pArea->fTrigger )
{
if( !hb_dbfTriggerDo( pArea, EVENT_PRECLOSE, 0, NULL ) )
return FAILURE;
}
/* Reset parent rel struct */
pArea->lpdbPendingRel = NULL;
/* Update record and unlock records */
if( pArea->pDataFile )
{
/* update buffers */
SELF_GOCOLD( ( AREAP ) pArea );
/* Unlock all records */
SELF_UNLOCK( ( AREAP ) pArea, NULL );
/* Update header */
if( pArea->fUpdateHeader )
SELF_WRITEDBHEADER( ( AREAP ) pArea );
/* It's not Clipper compatible but it reduces the problem with
byggy Windows network setting */
if( hb_setGetHardCommit() )
SELF_FLUSH( ( AREAP ) pArea );
}
SUPER_CLOSE( ( AREAP ) pArea );
if( pArea->pDataFile )
{
hb_fileClose( pArea->pDataFile );
pArea->pDataFile = NULL;
}
/* Close the memo file */
if( pArea->fHasMemo && pArea->pMemoFile )
{
hb_fileClose( pArea->pMemoFile );
pArea->pMemoFile = NULL;
}
/* Free field offset array */
if( pArea->pFieldOffset )
{
hb_xfree( pArea->pFieldOffset );
pArea->pFieldOffset = NULL;
}
/* Free buffer */
if( pArea->pRecord )
{
hb_xfree( pArea->pRecord );
pArea->pRecord = NULL;
}
/* Free encryption password key */
if( pArea->pCryptKey )
{
memset( pArea->pCryptKey, '\0', 8 );
hb_xfree( pArea->pCryptKey );
pArea->pCryptKey = NULL;
}
/* Free all filenames */
if( pArea->szDataFileName )
{
hb_xfree( pArea->szDataFileName );
pArea->szDataFileName = NULL;
}
if( pArea->szMemoFileName )
{
hb_xfree( pArea->szMemoFileName );
pArea->szMemoFileName = NULL;
}
if( pArea->fTrigger )
{
hb_dbfTriggerDo( pArea, EVENT_POSTCLOSE, 0, NULL );
pArea->fTrigger = FALSE;
}
return SUCCESS;
}
| dbf1.c | 2621 |
| STATIC ERRCODE | hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
static ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
{
ERRCODE errCode = SUCCESS;
ULONG ulSize;
USHORT uiCount;
BOOL fRetry, fError, fRawBlob;
DBFFIELD * pThisField;
BYTE * pBuffer;
PHB_FNAME pFileName;
PHB_ITEM pItem = NULL, pError;
BYTE szFileName[ _POSIX_PATH_MAX + 1 ];
HB_TRACE(HB_TR_DEBUG, ("hb_dbfCreate(%p, %p)", pArea, pCreateInfo));
pArea->lpdbOpenInfo = pCreateInfo;
pFileName = hb_fsFNameSplit( ( char * ) pCreateInfo->abName );
if( ! pFileName->szExtension && hb_setGetDefExtension() )
{
pItem = hb_itemPutC( pItem, NULL );
if( SELF_INFO( ( AREAP ) pArea, DBI_TABLEEXT, pItem ) != SUCCESS )
{
hb_itemRelease( pItem );
hb_xfree( pFileName );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
pFileName->szExtension = hb_itemGetCPtr( pItem );
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
}
else
{
hb_strncpy( ( char * ) szFileName, ( char * ) pCreateInfo->abName, sizeof( szFileName ) - 1 );
}
hb_xfree( pFileName );
pItem = hb_itemPutL( pItem, FALSE );
fRawBlob = SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_BLOB_SUPPORT, pCreateInfo->ulConnection, pItem ) == SUCCESS &&
hb_itemGetL( pItem );
if( pArea->bTableType == 0 )
{
pItem = hb_itemPutNI( pItem, 0 );
if( SELF_INFO( ( AREAP ) pArea, DBI_TABLETYPE, pItem ) != SUCCESS )
{
hb_itemRelease( pItem );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
pArea->bTableType = hb_itemGetNI( pItem );
}
if( pArea->bLockType == 0 )
{
pItem = hb_itemPutNI( pItem, 0 );
if( SELF_INFO( ( AREAP ) pArea, DBI_LOCKSCHEME, pItem ) != SUCCESS )
{
hb_itemRelease( pItem );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
pArea->bLockType = hb_itemGetNI( pItem );
if( pArea->bLockType == 0 )
{
pArea->bLockType = DB_DBFLOCK_CLIP;
}
}
if( pArea->bTableType == DB_DBF_VFP && !fRawBlob )
{
pArea->bMemoType = DB_MEMO_FPT;
}
else if( pArea->bMemoType == 0 )
{
/* get memo type */
pItem = hb_itemPutNI( pItem, 0 );
if( SELF_INFO( ( AREAP ) pArea, DBI_MEMOTYPE, pItem ) != SUCCESS )
{
hb_itemRelease( pItem );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
pArea->bMemoType = ( BYTE ) hb_itemGetNI( pItem );
}
pArea->bCryptType = DB_CRYPT_NONE;
if( pItem )
hb_itemRelease( pItem );
if( pArea->uiFieldCount * sizeof( DBFFIELD ) + sizeof( DBFHEADER ) +
( pArea->bTableType == DB_DBF_VFP ? 1 : 2 ) > UINT16_MAX )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_CREATE );
hb_errPutSubCode( pError, EDBF_DATAWIDTH );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CREATE ) );
hb_errPutFileName( pError, ( char * ) pCreateInfo->abName );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
if( !fRawBlob )
{
pError = NULL;
/* Try create */
do
{
pArea->pDataFile = hb_fileExtOpen( szFileName, NULL,
FO_READWRITE | FO_EXCLUSIVE | FXO_TRUNCATE |
FXO_DEFAULTS | FXO_SHARELOCK | FXO_COPYNAME,
NULL, pError );
if( ! pArea->pDataFile )
{
if( !pError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_CREATE );
hb_errPutSubCode( pError, EDBF_CREATE_DBF );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CREATE ) );
hb_errPutFileName( pError, ( char * ) szFileName );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
}
hb_errPutOsCode( pError, hb_fsError() );
fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
}
else
fRetry = FALSE;
} while( fRetry );
if( pError )
{
hb_itemRelease( pError );
}
if( ! pArea->pDataFile )
{
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
}
pArea->szDataFileName = hb_strdup( ( char * ) szFileName );
ulSize = pArea->uiFieldCount * sizeof( DBFFIELD ) +
( pArea->bTableType == DB_DBF_VFP ? 1 : 2 );
if( pArea->uiFieldCount )
{
pBuffer = ( BYTE * ) hb_xgrab( ulSize + 1 );
memset( pBuffer, 0, ulSize );
}
else
{
pBuffer = NULL;
}
pThisField = ( DBFFIELD * ) pBuffer;
pArea->fHasMemo = fError = FALSE;
/* Size for deleted flag */
pArea->uiRecordLen = 1;
for( uiCount = 0; uiCount < pArea->uiFieldCount; uiCount++ )
{
LPFIELD pField = pArea->lpFields + uiCount;
hb_strncpy( ( char * ) pThisField->bName,
hb_dynsymName( ( PHB_DYNS ) pField->sym ), sizeof( pThisField->bName ) - 1 );
pArea->pFieldOffset[ uiCount ] = pArea->uiRecordLen;
/* field offset */
if( pArea->bTableType == DB_DBF_VFP )
HB_PUT_LE_UINT16( pThisField->bReserved1, pArea->uiRecordLen );
switch( pField->uiType )
{
case HB_FT_STRING:
pThisField->bType = 'C';
pThisField->bLen = ( BYTE ) pField->uiLen;
pThisField->bDec = ( BYTE ) ( pField->uiLen >> 8 );
pArea->uiRecordLen += pField->uiLen;
break;
case HB_FT_LOGICAL:
pThisField->bType = 'L';
pThisField->bLen = 1;
pArea->uiRecordLen++;
break;
case HB_FT_MEMO:
pThisField->bType = 'M';
if( pField->uiLen != 4 || pArea->bMemoType == DB_MEMO_SMT )
pField->uiLen = 10;
pThisField->bLen = ( BYTE ) pField->uiLen;
pArea->uiRecordLen += pField->uiLen;
pArea->fHasMemo = TRUE;
break;
case HB_FT_BLOB:
pThisField->bType = 'W';
if( pField->uiLen != 4 || pArea->bMemoType == DB_MEMO_SMT )
pField->uiLen = 10;
pThisField->bLen = ( BYTE ) pField->uiLen;
pThisField->bFieldFlags = HB_FF_BINARY;
pArea->uiRecordLen += pField->uiLen;
pArea->fHasMemo = TRUE;
break;
case HB_FT_IMAGE:
pThisField->bType = 'P';
if( pField->uiLen != 4 || pArea->bMemoType == DB_MEMO_SMT )
pField->uiLen = 10;
pThisField->bLen = ( BYTE ) pField->uiLen;
pThisField->bFieldFlags = HB_FF_BINARY;
pArea->uiRecordLen += pField->uiLen;
pArea->fHasMemo = TRUE;
break;
case HB_FT_OLE:
pThisField->bType = 'G';
if( pField->uiLen != 4 || pArea->bMemoType == DB_MEMO_SMT )
pField->uiLen = 10;
pThisField->bLen = ( BYTE ) pField->uiLen;
pThisField->bFieldFlags = HB_FF_BINARY;
pArea->uiRecordLen += pField->uiLen;
pArea->fHasMemo = TRUE;
break;
case HB_FT_ANY:
pThisField->bType = 'V';
if( pField->uiLen < 3 || pField->uiLen == 5 )
{
pField->uiLen = 6;
}
pThisField->bLen = ( BYTE ) pField->uiLen;
pThisField->bDec = ( BYTE ) ( pField->uiLen >> 8 );
pArea->uiRecordLen += pField->uiLen;
if( pThisField->bLen >= 6 )
{
pArea->uiMemoVersion = DB_MEMOVER_SIX;
pArea->fHasMemo = TRUE;
}
/*
if( pArea->bTableType == DB_DBF_VFP )
fError = TRUE;
*/
break;
case HB_FT_DATE:
pThisField->bType = 'D';
if( pField->uiLen != 3 && pField->uiLen != 4 )
{
pField->uiLen = pThisField->bLen = 8;
}
pThisField->bLen = ( BYTE ) pField->uiLen;
pArea->uiRecordLen += pField->uiLen;
break;
case HB_FT_LONG:
pThisField->bType = 'N';
pThisField->bLen = ( BYTE ) pField->uiLen;
pThisField->bDec = ( BYTE ) pField->uiDec;
pArea->uiRecordLen += pField->uiLen;
break;
case HB_FT_FLOAT:
pThisField->bType = 'F';
pThisField->bLen = ( BYTE ) pField->uiLen;
pThisField->bDec = ( BYTE ) pField->uiDec;
pArea->uiRecordLen += pField->uiLen;
break;
case HB_FT_DOUBLE:
case HB_FT_CURDOUBLE:
pThisField->bType = 'B';
pField->uiLen = 8;
pThisField->bLen = ( BYTE ) pField->uiLen;
pThisField->bDec = ( BYTE ) pField->uiDec;
pArea->uiRecordLen += pField->uiLen;
break;
case HB_FT_INTEGER:
case HB_FT_CURRENCY:
pThisField->bType = ( pArea->bTableType == DB_DBF_VFP &&
pField->uiLen == 8 && pField->uiDec == 4 ) ?
'Y' : 'I';
if( ( pField->uiLen > 4 && pField->uiLen != 8 ) ||
pField->uiLen == 0 )
{
pField->uiLen = 4;
}
pThisField->bLen = ( BYTE ) pField->uiLen;
pThisField->bDec = ( BYTE ) pField->uiDec;
pArea->uiRecordLen += pField->uiLen;
break;
case HB_FT_TIME:
pThisField->bType = 'T';
pField->uiLen = 4;
pThisField->bLen = ( BYTE ) pField->uiLen;
pArea->uiRecordLen += pField->uiLen;
break;
case HB_FT_DAYTIME:
pThisField->bType = pArea->bTableType == DB_DBF_VFP ? 'T' : '@';
pField->uiLen = 8;
pThisField->bLen = ( BYTE ) pField->uiLen;
pThisField->bFieldFlags = HB_FF_BINARY;
pArea->uiRecordLen += pField->uiLen;
break;
case HB_FT_MODTIME:
pThisField->bType = '=';
pField->uiLen = 8;
pThisField->bLen = ( BYTE ) pField->uiLen;
pArea->uiRecordLen += pField->uiLen;
pArea->fModStamp = TRUE;
break;
case HB_FT_ROWVER:
pThisField->bType = '^';
pField->uiLen = 8;
pThisField->bLen = ( BYTE ) pField->uiLen;
HB_PUT_LE_UINT32( pThisField->bCounter, 1 );
pThisField->bStep = 1;
pArea->uiRecordLen += pField->uiLen;
pArea->fModStamp = TRUE;
break;
case HB_FT_AUTOINC:
pThisField->bType = '+';
pField->uiLen = 4;
pThisField->bLen = ( BYTE ) pField->uiLen;
HB_PUT_LE_UINT32( pThisField->bCounter, 1 );
pThisField->bStep = 1;
pArea->uiRecordLen += pField->uiLen;
pArea->fAutoInc = TRUE;
break;
default:
fError = TRUE;
}
if( fError )
{
hb_xfree( pBuffer );
SELF_CLOSE( ( AREAP ) pArea );
pError = hb_errNew();
hb_errPutGenCode( pError, EG_CREATE );
hb_errPutSubCode( pError, EDBF_DATATYPE );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CREATE ) );
hb_errPutFileName( pError, ( char * ) pCreateInfo->abName );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
pThisField++;
}
pArea->fShared = FALSE; /* pCreateInfo->fShared; */
pArea->fReadonly = FALSE; /* pCreateInfo->fReadonly */
pArea->ulRecCount = 0;
pArea->uiHeaderLen = ( USHORT ) ( sizeof( DBFHEADER ) + ulSize );
if( fRawBlob )
{
pArea->fHasMemo = TRUE;
}
if( !pArea->fHasMemo )
{
pArea->bMemoType = DB_MEMO_NONE;
}
pArea->uiMemoBlockSize = 0;
#ifndef HB_CDP_SUPPORT_OFF
if( pCreateInfo->cdpId )
{
pArea->cdPage = hb_cdpFind( (char *) pCreateInfo->cdpId );
if( !pArea->cdPage )
pArea->cdPage = hb_vmCDP();
}
else
pArea->cdPage = hb_vmCDP();
#endif
pItem = hb_itemNew( NULL );
if( SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_PENDINGPASSWORD,
pCreateInfo->ulConnection, pItem ) == SUCCESS )
{
if( hb_dbfPasswordSet( pArea, pItem, FALSE ) )
pArea->fTableEncrypted = TRUE;
}
else
{
hb_itemClear( pItem );
if( SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_PASSWORD,
pCreateInfo->ulConnection, pItem ) == SUCCESS )
{
if( hb_dbfPasswordSet( pArea, pItem, FALSE ) )
pArea->fTableEncrypted = TRUE;
}
}
hb_itemRelease( pItem );
if( !fRawBlob )
{
/* Force write new header */
pArea->fUpdateHeader = TRUE;
/* Write header */
errCode = SELF_WRITEDBHEADER( ( AREAP ) pArea );
if( errCode != SUCCESS )
{
hb_xfree( pBuffer );
SELF_CLOSE( ( AREAP ) pArea );
pArea->lpdbOpenInfo = NULL;
return errCode;
}
/* Write fields and eof mark */
if( pArea->bTableType == DB_DBF_VFP )
pBuffer[ ulSize - 1 ] = '\r';
else
{
pBuffer[ ulSize - 2 ] = '\r';
pBuffer[ ulSize - 1 ] = '\0';
}
pBuffer[ ulSize ] = ' ';
if( hb_fileWriteAt( pArea->pDataFile, pBuffer, ulSize + 1,
sizeof( DBFHEADER ) ) != ulSize + 1 )
{
/* TODO: add RT error */
hb_xfree( pBuffer );
SELF_CLOSE( ( AREAP ) pArea );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
pArea->fDataFlush = TRUE;
hb_xfree( pBuffer );
}
/* Create memo file */
if( pArea->fHasMemo )
{
pFileName = hb_fsFNameSplit( ( char * ) szFileName );
pFileName->szExtension = NULL;
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
hb_xfree( pFileName );
pCreateInfo->abName = szFileName;
errCode = SELF_CREATEMEMFILE( ( AREAP ) pArea, pCreateInfo );
}
/* If successful call SUPER_CREATE to finish system jobs */
if( errCode == SUCCESS )
{
errCode = SUPER_CREATE( ( AREAP ) pArea, pCreateInfo );
}
if( errCode != SUCCESS )
{
SELF_CLOSE( ( AREAP ) pArea );
pArea->lpdbOpenInfo = NULL;
return errCode;
}
/* Alloc buffer */
pArea->pRecord = ( BYTE * ) hb_xgrab( pArea->uiRecordLen );
pArea->fValidBuffer = FALSE;
/* Update the number of record for corrupted headers */
pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
pArea->lpdbOpenInfo = NULL;
/* Position cursor at the first record */
return SELF_GOTOP( ( AREAP ) pArea );
}
| dbf1.c | 2714 |
| STATIC ERRCODE | hb_dbfInfo( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
static ERRCODE hb_dbfInfo( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
ERRCODE errCode = SUCCESS;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfInfo(%p, %hu, %p)", pArea, uiIndex, pItem));
switch( uiIndex )
{
case DBI_ISDBF:
case DBI_CANPUTREC:
hb_itemPutL( pItem, TRUE );
break;
case DBI_GETHEADERSIZE:
hb_itemPutNL( pItem, pArea->uiHeaderLen );
break;
case DBI_LASTUPDATE:
hb_itemPutD( pItem, 1900 + pArea->dbfHeader.bYear,
pArea->dbfHeader.bMonth,
pArea->dbfHeader.bDay );
break;
case DBI_GETRECSIZE:
hb_itemPutNL( pItem, pArea->uiRecordLen );
break;
case DBI_GETLOCKARRAY:
hb_dbfGetLockArray( pArea, pItem );
break;
case DBI_TABLEEXT:
hb_itemClear( pItem );
return SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_TABLEEXT, 0, pItem );
case DBI_FULLPATH:
hb_itemPutC( pItem, pArea->szDataFileName);
break;
case DBI_MEMOTYPE:
hb_itemPutNI( pItem, DB_MEMO_NONE );
break;
case DBI_TABLETYPE:
if( !pArea->pDataFile )
{
hb_itemClear( pItem );
return SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_TABLETYPE, 0, pItem );
}
hb_itemPutNI( pItem, pArea->bTableType );
break;
case DBI_FILEHANDLE:
hb_itemPutNInt( pItem, ( HB_NHANDLE ) hb_fileHandle( pArea->pDataFile ) );
break;
case DBI_MEMOHANDLE:
hb_itemPutNInt( pItem, ( HB_NHANDLE ) hb_fileHandle( pArea->pMemoFile ) );
break;
case DBI_SHARED:
{
BOOL fShared = pArea->fShared;
if( HB_IS_LOGICAL( pItem ) )
{
pArea->fShared = hb_itemGetL( pItem );
}
hb_itemPutL( pItem, fShared );
break;
}
case DBI_ISFLOCK:
hb_itemPutL( pItem, pArea->fFLocked );
break;
case DBI_ISREADONLY:
hb_itemPutL( pItem, pArea->fReadonly );
break;
case DBI_VALIDBUFFER:
hb_itemPutL( pItem, pArea->fValidBuffer );
break;
case DBI_POSITIONED:
hb_itemPutL( pItem, pArea->fPositioned );
break;
case DBI_ISENCRYPTED:
hb_itemPutL( pItem, pArea->fTableEncrypted );
break;
case DBI_DECRYPT:
hb_dbfTableCrypt( pArea, pItem, FALSE );
hb_itemPutL( pItem, !pArea->fTableEncrypted );
break;
case DBI_ENCRYPT:
hb_dbfTableCrypt( pArea, pItem, TRUE );
hb_itemPutL( pItem, pArea->fTableEncrypted );
break;
case DBI_LOCKCOUNT:
hb_itemPutNL( pItem, pArea->ulNumLocksPos );
break;
case DBI_LOCKOFFSET:
{
HB_FOFFSET ulPos, ulFlSize, ulRlSize;
int iDir;
hb_dbfLockData( pArea, &ulPos, &ulFlSize, &ulRlSize, &iDir );
hb_itemPutNInt( pItem, ulPos );
break;
}
case DBI_LOCKSCHEME:
{
int iScheme = hb_itemGetNI( pItem );
if( pArea->bLockType )
{
hb_itemPutNI( pItem, pArea->bLockType );
}
else
{
hb_itemClear( pItem );
errCode = SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_LOCKSCHEME, 0, pItem );
}
switch( iScheme )
{
case DB_DBFLOCK_CLIP:
case DB_DBFLOCK_CL53:
case DB_DBFLOCK_CL53EXT:
case DB_DBFLOCK_VFP:
#ifndef HB_LONG_LONG_OFF
case DB_DBFLOCK_XHB64:
#endif
pArea->bLockType = ( BYTE ) iScheme;
}
break;
}
case DBI_ROLLBACK:
if( pArea->fRecordChanged )
{
if( pArea->fAppend )
{
hb_dbfSetBlankRecord( pArea, HB_BLANK_ROLLBACK );
pArea->fDeleted = FALSE;
}
else
{
pArea->fRecordChanged = pArea->fValidBuffer = FALSE;
}
}
break;
case DBI_PASSWORD:
hb_dbfPasswordSet( pArea, pItem, FALSE );
break;
case DBI_TRIGGER:
if( HB_IS_LOGICAL( pItem ) )
pArea->fTrigger = pArea->pTriggerSym && hb_itemGetL( pItem );
else
{
PHB_DYNS pTriggerSym = pArea->pTriggerSym;
if( HB_IS_STRING( pItem ) )
hb_dbfTriggerSet( pArea, pItem );
hb_itemPutC( pItem, pTriggerSym ? hb_dynsymName( pTriggerSym ) : NULL );
}
break;
case DBI_OPENINFO:
hb_itemPutPtr( pItem, pArea->lpdbOpenInfo );
break;
case DBI_DIRTYREAD:
{
BOOL fDirty = HB_DIRTYREAD( pArea );
if( HB_IS_LOGICAL( pItem ) )
pArea->uiDirtyRead = hb_itemGetL( pItem ) ?
HB_IDXREAD_DIRTY : HB_IDXREAD_CLEAN;
else if( !HB_IS_NIL( pItem ) )
pArea->uiDirtyRead = HB_IDXREAD_DEFAULT;
hb_itemPutL( pItem, fDirty );
break;
}
case DBI_DB_VERSION:
case DBI_RDD_VERSION:
{
char szBuf[ 64 ];
int iSub = hb_itemGetNI( pItem );
if( iSub == 1 )
snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s)", 0, 1, "DBF" );
else if( iSub == 2 )
snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s:%d)", 0, 1, "DBF", pArea->rddID );
/*
snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s:%d)", 0, 1, pArea->pRddNode->szName, pArea->rddID );
*/
else
snprintf( szBuf, sizeof( szBuf ), "%d.%d", 0, 1 );
hb_itemPutC( pItem, szBuf );
break;
}
default:
return SUPER_INFO( ( AREAP ) pArea, uiIndex, pItem );
}
return errCode;
}
| dbf1.c | 3193 |
| STATIC ERRCODE | hb_dbfRecInfo( DBFAREAP pArea, PHB_ITEM pRecID, USHORT uiInfoType, PHB_ITEM pInfo )
static ERRCODE hb_dbfRecInfo( DBFAREAP pArea, PHB_ITEM pRecID, USHORT uiInfoType, PHB_ITEM pInfo )
{
ULONG ulRecNo = hb_itemGetNL( pRecID ), ulPrevRec = 0;
ERRCODE errResult = SUCCESS;
BOOL bDeleted;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfRecInfo(%p, %p, %hu, %p)", pArea, pRecID, uiInfoType, pInfo));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
if( ulRecNo == 0 )
{
ulRecNo = pArea->ulRecNo;
}
else if( ulRecNo != pArea->ulRecNo )
{
switch( uiInfoType )
{
case DBRI_DELETED:
case DBRI_ENCRYPTED:
case DBRI_RAWRECORD:
case DBRI_RAWMEMOS:
case DBRI_RAWDATA:
ulPrevRec = pArea->ulRecNo;
errResult = SELF_GOTO( ( AREAP ) pArea, ulRecNo );
if( errResult != SUCCESS )
return errResult;
break;
}
}
switch( uiInfoType )
{
case DBRI_DELETED:
errResult = SELF_DELETED( ( AREAP ) pArea, &bDeleted );
if( errResult == SUCCESS )
hb_itemPutL( pInfo, bDeleted );
break;
case DBRI_LOCKED:
/* Clipper also checks only fShared and RLOCK and ignore FLOCK */
hb_itemPutL( pInfo, !pArea->fShared || /* pArea->fFLocked || */
hb_dbfIsLocked( pArea, ulRecNo ) );
break;
case DBRI_RECSIZE:
hb_itemPutNL( pInfo, pArea->uiRecordLen );
break;
case DBRI_RECNO:
hb_itemPutNL( pInfo, ulRecNo );
break;
case DBRI_UPDATED:
hb_itemPutL( pInfo, ulRecNo == pArea->ulRecNo && pArea->fRecordChanged );
break;
case DBRI_ENCRYPTED:
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
errResult = FAILURE;
else
hb_itemPutL( pInfo, pArea->fEncrypted );
break;
case DBRI_RAWRECORD:
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
errResult = FAILURE;
else
hb_itemPutCL( pInfo, ( char * ) pArea->pRecord, pArea->uiRecordLen );
break;
case DBRI_RAWMEMOS:
case DBRI_RAWDATA:
{
USHORT uiFields;
BYTE *pResult;
ULONG ulLength, ulLen;
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
{
errResult = FAILURE;
break;
}
ulLength = uiInfoType == DBRI_RAWDATA ? pArea->uiRecordLen : 0;
pResult = ( BYTE * ) hb_xgrab( ulLength + 1 );
if( ulLength )
{
memcpy( pResult, pArea->pRecord, ulLength );
}
if( pArea->fHasMemo )
{
for( uiFields = 0; uiFields < pArea->uiFieldCount; uiFields++ )
{
if( pArea->lpFields[ uiFields ].uiType == HB_FT_MEMO ||
pArea->lpFields[ uiFields ].uiType == HB_FT_IMAGE ||
pArea->lpFields[ uiFields ].uiType == HB_FT_BLOB ||
pArea->lpFields[ uiFields ].uiType == HB_FT_OLE )
{
errResult = SELF_GETVALUE( ( AREAP ) pArea, uiFields + 1, pInfo );
if( errResult != SUCCESS )
break;
ulLen = hb_itemGetCLen( pInfo );
if( ulLen > 0 )
{
pResult = ( BYTE * ) hb_xrealloc( pResult, ulLength + ulLen + 1 );
memcpy( pResult + ulLength, hb_itemGetCPtr( pInfo ), ulLen );
ulLength += ulLen;
}
}
}
}
hb_itemPutCLPtr( pInfo, ( char * ) pResult, ulLength );
break;
}
default:
errResult = SUPER_RECINFO( ( AREAP ) pArea, pRecID, uiInfoType, pInfo );
}
if( ulPrevRec != 0 )
{
if( SELF_GOTO( ( AREAP ) pArea, ulPrevRec ) != SUCCESS &&
errResult == SUCCESS )
errResult = FAILURE;
}
return errResult;
}
| dbf1.c | 3411 |
| STATIC ERRCODE | hb_dbfNewArea( DBFAREAP pArea )
static ERRCODE hb_dbfNewArea( DBFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfNewArea(%p)", pArea));
if( SUPER_NEW( ( AREAP ) pArea ) == FAILURE )
return FAILURE;
pArea->pDataFile = pArea->pMemoFile = pArea->pMemoTmpFile = NULL;
pArea->fDataFlush = pArea->fMemoFlush = FALSE;
/* Index dirty read flag initialized to global RDD setting */
pArea->uiDirtyRead = HB_IDXREAD_DEFAULT;
/* Size for deleted records flag */
pArea->uiRecordLen = 1;
return SUCCESS;
}
| dbf1.c | 3546 |
| STATIC ERRCODE | hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
static ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
{
ERRCODE errCode;
USHORT uiFlags, uiFields, uiCount, uiSkip;
ULONG ulSize;
BOOL fRetry, fRawBlob;
PHB_ITEM pError, pItem;
PHB_FNAME pFileName;
BYTE * pBuffer;
LPDBFFIELD pField;
DBFIELDINFO dbFieldInfo;
BYTE szFileName[ _POSIX_PATH_MAX + 1 ];
char szAlias[ HB_RDD_MAX_ALIAS_LEN + 1 ];
HB_TRACE(HB_TR_DEBUG, ("hb_dbfOpen(%p, %p)", pArea, pOpenInfo));
pArea->lpdbOpenInfo = pOpenInfo;
pItem = hb_itemNew( NULL );
if( SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_PENDINGTRIGGER,
pOpenInfo->ulConnection, pItem ) == SUCCESS )
{
if( HB_IS_STRING( pItem ) )
hb_dbfTriggerSet( pArea, pItem );
}
if( !pArea->fTrigger )
{
if( SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_TRIGGER,
pOpenInfo->ulConnection, pItem ) == SUCCESS )
{
if( HB_IS_STRING( pItem ) )
hb_dbfTriggerSet( pArea, pItem );
}
}
if( pArea->fTrigger )
{
hb_itemPutC( pItem, ( char * ) pOpenInfo->abName );
if( !hb_dbfTriggerDo( pArea, EVENT_PREUSE, 0, pItem ) )
{
hb_itemRelease( pItem );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
hb_strncpy( ( char * ) szFileName, hb_itemGetCPtr( pItem ), sizeof( szFileName ) - 1 );
}
else
hb_strncpy( ( char * ) szFileName, ( char * ) pOpenInfo->abName, sizeof( szFileName ) - 1 );
if( !pArea->bLockType )
{
hb_itemClear( pItem );
if( SELF_INFO( ( AREAP ) pArea, DBI_LOCKSCHEME, pItem ) != SUCCESS )
{
hb_itemRelease( pItem );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
pArea->bLockType = hb_itemGetNI( pItem );
if( !pArea->bLockType )
pArea->bLockType = DB_DBFLOCK_CLIP;
}
#ifndef HB_CDP_SUPPORT_OFF
if( pOpenInfo->cdpId )
{
pArea->cdPage = hb_cdpFind( (char *) pOpenInfo->cdpId );
if( !pArea->cdPage )
pArea->cdPage = hb_vmCDP();
}
else
pArea->cdPage = hb_vmCDP();
#endif
pArea->fShared = pOpenInfo->fShared;
pArea->fReadonly = pOpenInfo->fReadonly;
/* Force exclusive mode
* 0: AUTOSHARE disabled.
* 1: AUTOSHARE enabled.
* 2: force exclusive mode.
* */
if( hb_setGetAutoShare() == 2 )
pArea->fShared = FALSE;
uiFlags = (pArea->fReadonly ? FO_READ : FO_READWRITE) |
(pArea->fShared ? FO_DENYNONE : FO_EXCLUSIVE);
pError = NULL;
pFileName = hb_fsFNameSplit( ( char * ) szFileName );
/* Add default file name extension if necessary */
if( ! pFileName->szExtension && hb_setGetDefExtension() )
{
hb_itemClear( pItem );
if( SELF_INFO( ( AREAP ) pArea, DBI_TABLEEXT, pItem ) != SUCCESS )
{
hb_xfree( pFileName );
hb_itemRelease( pItem );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
pFileName->szExtension = hb_itemGetCPtr( pItem );
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
}
/* Create default alias if necessary */
if( !pOpenInfo->atomAlias && pFileName->szName )
{
hb_strncpyUpperTrim( szAlias, pFileName->szName, sizeof( szAlias ) - 1 );
pOpenInfo->atomAlias = ( BYTE * ) szAlias;
}
hb_xfree( pFileName );
hb_itemClear( pItem );
fRawBlob = SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_BLOB_SUPPORT, pOpenInfo->ulConnection, pItem ) == SUCCESS &&
hb_itemGetL( pItem );
hb_itemRelease( pItem );
if( fRawBlob )
{
uiFields = uiSkip = 0;
pBuffer = NULL;
pArea->fHasMemo = TRUE;
}
else
{
/* Try open */
do
{
pArea->pDataFile = hb_fileExtOpen( szFileName, NULL, uiFlags |
FXO_DEFAULTS | FXO_SHARELOCK | FXO_COPYNAME,
NULL, pError );
if( !pArea->pDataFile )
{
if( !pError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_OPEN );
hb_errPutSubCode( pError, EDBF_OPEN_DBF );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_OPEN ) );
hb_errPutFileName( pError, ( char * ) szFileName );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
}
hb_errPutOsCode( pError, hb_fsError() );
fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
}
else
fRetry = FALSE;
} while( fRetry );
if( pError )
{
hb_itemRelease( pError );
pError = NULL;
}
/* Exit if error */
if( !pArea->pDataFile )
{
SELF_CLOSE( ( AREAP ) pArea );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
/* Allocate only after succesfully open file */
pArea->szDataFileName = hb_strdup( ( char * ) szFileName );
/* Read file header and exit if error */
errCode = SELF_READDBHEADER( ( AREAP ) pArea );
if( errCode != SUCCESS )
{
SELF_CLOSE( ( AREAP ) pArea );
pArea->lpdbOpenInfo = NULL;
return errCode;
}
/* Add fields */
uiSkip = 0;
uiFields = ( pArea->uiHeaderLen - sizeof( DBFHEADER ) ) / sizeof( DBFFIELD );
ulSize = ( ULONG ) uiFields * sizeof( DBFFIELD );
pBuffer = uiFields ? ( BYTE * ) hb_xgrab( ulSize ) : NULL;
/* Read fields and exit if error */
do
{
if( hb_fileReadAt( pArea->pDataFile, pBuffer, ulSize,
sizeof( DBFHEADER ) ) != ulSize )
{
errCode = FAILURE;
if( !pError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_CORRUPTION );
hb_errPutSubCode( pError, EDBF_CORRUPT );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CORRUPTION ) );
hb_errPutFileName( pError, pArea->szDataFileName );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
}
fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
}
else
{
errCode = SUCCESS;
break;
}
} while( fRetry );
if( pError )
{
hb_itemRelease( pError );
}
/* Exit if error */
if( errCode != SUCCESS )
{
if( pBuffer )
hb_xfree( pBuffer );
SELF_CLOSE( ( AREAP ) pArea );
pArea->lpdbOpenInfo = NULL;
return errCode;
}
/* some RDDs use the additional space in the header after field arrray
for private data we should check for 0x0D marker to not use this
data as fields description */
for( uiCount = 0; uiCount < uiFields; uiCount++ )
{
pField = ( LPDBFFIELD ) ( pBuffer + uiCount * sizeof( DBFFIELD ) );
if( pField->bName[ 0 ] == 0x0d )
{
uiFields = uiCount;
break;
}
else if( pArea->bTableType == DB_DBF_VFP &&
pField->bFieldFlags & 0x01 )
{
uiSkip++;
}
}
uiFields -= uiSkip;
}
/* CL5.3 allow to create and open DBFs without fields */
#ifdef HB_C52_STRICT
if( uiFields == 0 )
{
errCode = FAILURE;
}
else
#endif
{
errCode = SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
if( errCode != SUCCESS )
{
SELF_CLOSE( ( AREAP ) pArea );
pArea->lpdbOpenInfo = NULL;
return errCode;
}
}
/* Clear dbFieldInfo structure */
memset( &dbFieldInfo, 0, sizeof( dbFieldInfo ) );
/* Size for deleted flag */
pArea->uiRecordLen = 1;
for( uiCount = 0; uiCount < uiFields + uiSkip; uiCount++ )
{
pField = ( LPDBFFIELD ) ( pBuffer + uiCount * sizeof( DBFFIELD ) );
dbFieldInfo.atomName = pField->bName;
dbFieldInfo.atomName[10] = '\0';
/* hb_strUpper( (char *) dbFieldInfo.atomName, 11 ); */
dbFieldInfo.uiLen = pField->bLen;
dbFieldInfo.uiDec = 0;
dbFieldInfo.uiTypeExtended = 0;
/* We cannot accept bFieldFlags as is because Clipper
* creates tables where this field is random so we have to
* try to guess the flags ourself. But if we know that table
* was created by VFP which uses field flags then we can
* retrive information from bFieldFlags.
*/
if( pArea->bTableType == DB_DBF_VFP )
dbFieldInfo.uiFlags = pField->bFieldFlags;
else
dbFieldInfo.uiFlags = 0;
switch( pField->bType )
{
case 'C':
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiLen = pField->bLen + pField->bDec * 256;
break;
case 'L':
dbFieldInfo.uiType = HB_FT_LOGICAL;
dbFieldInfo.uiLen = 1;
break;
case 'D':
dbFieldInfo.uiType = HB_FT_DATE;
if( dbFieldInfo.uiLen != 3 && dbFieldInfo.uiLen != 4 )
dbFieldInfo.uiLen = 8;
break;
case 'I':
dbFieldInfo.uiType = HB_FT_INTEGER;
if( ( dbFieldInfo.uiLen > 4 && dbFieldInfo.uiLen != 8 ) ||
dbFieldInfo.uiLen == 0 )
dbFieldInfo.uiLen = 4;
dbFieldInfo.uiDec = pField->bDec;
break;
case 'Y':
dbFieldInfo.uiType = HB_FT_CURRENCY;
if( ( dbFieldInfo.uiLen > 4 && dbFieldInfo.uiLen != 8 ) ||
dbFieldInfo.uiLen == 0 )
dbFieldInfo.uiLen = 8;
dbFieldInfo.uiDec = pField->bDec;
break;
case '2':
case '4':
dbFieldInfo.uiType = HB_FT_INTEGER;
dbFieldInfo.uiLen = pField->bType - '0';
break;
case 'N':
dbFieldInfo.uiType = HB_FT_LONG;
dbFieldInfo.uiDec = pField->bDec;
/* DBASE documentation defines maximum numeric field size as 20
* but Clipper allows to create longer fields so I removed this
* limit, Druzus
*/
/*
if( pField->bLen > 20 )
errCode = FAILURE;
*/
break;
case 'F':
dbFieldInfo.uiType = HB_FT_FLOAT;
dbFieldInfo.uiDec = pField->bDec;
/* See note above */
break;
case '8':
case 'B':
dbFieldInfo.uiType = HB_FT_DOUBLE;
dbFieldInfo.uiDec = pField->bDec;
if( dbFieldInfo.uiLen != 8 )
errCode = FAILURE;
break;
/* types which are not supported by VM - mapped to different ones */
case 'T':
if( dbFieldInfo.uiLen == 8 )
dbFieldInfo.uiType = HB_FT_DAYTIME;
else if( dbFieldInfo.uiLen == 4 )
dbFieldInfo.uiType = HB_FT_TIME;
else
errCode = FAILURE;
break;
case '@':
dbFieldInfo.uiType = HB_FT_DAYTIME;
if( dbFieldInfo.uiLen != 8 )
errCode = FAILURE;
break;
case '=':
dbFieldInfo.uiType = HB_FT_MODTIME;
if( dbFieldInfo.uiLen != 8 )
errCode = FAILURE;
pArea->fModStamp = TRUE;
break;
case '^':
dbFieldInfo.uiType = HB_FT_ROWVER;
if( dbFieldInfo.uiLen != 8 )
errCode = FAILURE;
pArea->fModStamp = TRUE;
break;
case '+':
dbFieldInfo.uiType = HB_FT_AUTOINC;
if( dbFieldInfo.uiLen != 4 )
errCode = FAILURE;
pArea->fAutoInc = TRUE;
break;
case 'Q':
dbFieldInfo.uiType = HB_FT_VARLENGTH;
dbFieldInfo.uiFlags |= HB_FF_BINARY;
break;
case 'V':
if( pArea->bTableType == DB_DBF_VFP )
{
dbFieldInfo.uiType = HB_FT_VARLENGTH;
}
else
{
dbFieldInfo.uiType = HB_FT_ANY;
if( dbFieldInfo.uiLen >= 6 )
{
pArea->uiMemoVersion = DB_MEMOVER_SIX;
pArea->fHasMemo = TRUE;
}
}
break;
case 'M':
dbFieldInfo.uiType = HB_FT_MEMO;
pArea->fHasMemo = TRUE;
break;
case 'P':
dbFieldInfo.uiType = HB_FT_IMAGE;
dbFieldInfo.uiFlags |= HB_FF_BINARY;
pArea->fHasMemo = TRUE;
break;
case 'W':
dbFieldInfo.uiType = HB_FT_BLOB;
dbFieldInfo.uiFlags |= HB_FF_BINARY;
pArea->fHasMemo = TRUE;
break;
case 'G':
dbFieldInfo.uiType = HB_FT_OLE;
dbFieldInfo.uiFlags |= HB_FF_BINARY;
pArea->fHasMemo = TRUE;
break;
case '0':
if( pArea->bTableType == DB_DBF_VFP && pField->bFieldFlags & 0x01 )
{
if( memcmp( dbFieldInfo.atomName, "_NullFlags", 10 ) == 0 )
{
/* TODO: NULLABLE and VARLENGTH support */
}
pArea->uiRecordLen += dbFieldInfo.uiLen;
continue;
}
default:
errCode = FAILURE;
break;
}
/* Add field */
if( errCode == SUCCESS )
errCode = SELF_ADDFIELD( ( AREAP ) pArea, &dbFieldInfo );
/* Exit if error */
if( errCode != SUCCESS )
break;
}
if( pBuffer )
hb_xfree( pBuffer );
/* Exit if error */
if( errCode != SUCCESS )
{
if( hb_vmRequestQuery() == 0 )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_CORRUPTION );
hb_errPutSubCode( pError, EDBF_CORRUPT );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CORRUPTION ) );
hb_errPutFileName( pError, pArea->szDataFileName );
hb_errPutFlags( pError, EF_CANDEFAULT );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
}
SELF_CLOSE( ( AREAP ) pArea );
pArea->lpdbOpenInfo = NULL;
return errCode;
}
pItem = hb_itemNew( NULL );
if( SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_PENDINGPASSWORD,
pOpenInfo->ulConnection, pItem ) == SUCCESS )
{
hb_dbfPasswordSet( pArea, pItem, FALSE );
}
else
{
hb_itemClear( pItem );
if( SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_PASSWORD,
pOpenInfo->ulConnection, pItem ) == SUCCESS )
{
hb_dbfPasswordSet( pArea, pItem, FALSE );
}
}
hb_itemRelease( pItem );
/* Open memo file if exists */
if( pArea->fHasMemo )
{
pFileName = hb_fsFNameSplit( ( char * ) szFileName );
pFileName->szExtension = NULL;
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
hb_xfree( pFileName );
pOpenInfo->abName = szFileName;
errCode = SELF_OPENMEMFILE( ( AREAP ) pArea, pOpenInfo );
}
if( errCode == SUCCESS )
{
/* If successful call SUPER_OPEN to finish system jobs */
errCode = SUPER_OPEN( ( AREAP ) pArea, pOpenInfo );
}
if( errCode != SUCCESS )
{
SELF_CLOSE( ( AREAP ) pArea );
pArea->lpdbOpenInfo = NULL;
return FAILURE;
}
/* Alloc buffer */
pArea->pRecord = ( BYTE * ) hb_xgrab( pArea->uiRecordLen );
pArea->fValidBuffer = FALSE;
/* Update the number of record for corrupted headers */
pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
/* Position cursor at the first record */
errCode = SELF_GOTOP( ( AREAP ) pArea );
if( pArea->fTrigger )
hb_dbfTriggerDo( pArea, EVENT_POSTUSE, 0, NULL );
pArea->lpdbOpenInfo = NULL;
return errCode;
}
| dbf1.c | 3565 |
| STATIC ERRCODE | hb_dbfStructSize( DBFAREAP pArea, USHORT * uiSize )
static ERRCODE hb_dbfStructSize( DBFAREAP pArea, USHORT * uiSize )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfStrucSize(%p, %p)", pArea, uiSize));
HB_SYMBOL_UNUSED( pArea );
* uiSize = sizeof( DBFAREA );
return SUCCESS;
}
| dbf1.c | 4104 |
| STATIC ERRCODE | hb_dbfPackRec( DBFAREAP pArea, ULONG ulRecNo, BOOL *fWritten )
static ERRCODE hb_dbfPackRec( DBFAREAP pArea, ULONG ulRecNo, BOOL *fWritten )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfPackRec(%p, %lu, %p)", pArea, ulRecNo, fWritten));
HB_SYMBOL_UNUSED( ulRecNo );
*fWritten = !pArea->fDeleted;
return SUCCESS;
}
| dbf1.c | 4116 |
| STATIC ERRCODE | hb_dbfPack( DBFAREAP pArea )
static ERRCODE hb_dbfPack( DBFAREAP pArea )
{
ULONG ulRecIn, ulRecOut, ulEvery, ulUserEvery;
PHB_ITEM pError, pBlock;
BOOL fWritten;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfPack(%p)", pArea));
if( pArea->fReadonly )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_READONLY );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_READONLY ) );
hb_errPutSubCode( pError, EDBF_READONLY );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
if( pArea->fShared )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_SHARED );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_SHARED ) );
hb_errPutSubCode( pError, EDBF_SHARED );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
if( pArea->fTrigger )
{
if( !hb_dbfTriggerDo( pArea, EVENT_PACK, 0, NULL ) )
return FAILURE;
}
if( SELF_GOCOLD( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
if( HB_IS_ARRAY( pArea->valResult ) && hb_arrayLen( pArea->valResult ) == 2 )
{
pBlock = hb_arrayGetItemPtr( pArea->valResult, 1 );
ulUserEvery = hb_arrayGetNL( pArea->valResult, 2 );
if( ulUserEvery < 1 )
ulUserEvery = 1;
}
else
{
pBlock = NULL;
ulUserEvery = 1;
}
ulRecOut = ulEvery = 0;
ulRecIn = 1;
while( ulRecIn <= pArea->ulRecCount )
{
if( SELF_GOTO( ( AREAP ) pArea, ulRecIn ) != SUCCESS )
return FAILURE;
if( !hb_dbfReadRecord( pArea ) )
return FAILURE;
/* Execute the Code Block */
if( pBlock )
{
if( ++ulEvery >= ulUserEvery )
{
ulEvery = 0;
if( SELF_EVALBLOCK( ( AREAP ) pArea, pBlock ) != SUCCESS )
return FAILURE;
}
}
if( SELF_PACKREC( ( AREAP ) pArea, ulRecOut + 1, &fWritten ) != SUCCESS )
return FAILURE;
if( fWritten )
{
ulRecOut++;
if( pArea->ulRecNo != ulRecOut || pArea->fRecordChanged )
{
pArea->ulRecNo = ulRecOut;
pArea->fRecordChanged = TRUE;
if( ! hb_dbfWriteRecord( pArea ) )
return FAILURE;
}
}
ulRecIn++;
}
/* Execute the Code Block for pending record */
if( pBlock && ulEvery > 0 )
{
if( SELF_EVALBLOCK( ( AREAP ) pArea, pBlock ) != SUCCESS )
return FAILURE;
}
if( pArea->ulRecCount != ulRecOut )
{
pArea->ulRecCount = ulRecOut;
/* Force write new header */
pArea->fUpdateHeader = TRUE;
if( SELF_WRITEDBHEADER( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
return SELF_GOTO( ( AREAP ) pArea, 1 );
}
| dbf1.c | 4130 |
| HB_EXPORT VOID | hb_dbfTranslateRec( DBFAREAP pArea, BYTE * pBuffer, PHB_CODEPAGE cdp_src, PHB_CODEPAGE cdp_dest )
HB_EXPORT void hb_dbfTranslateRec( DBFAREAP pArea, BYTE * pBuffer, PHB_CODEPAGE cdp_src, PHB_CODEPAGE cdp_dest )
{
USHORT uiIndex;
LPFIELD pField;
for( uiIndex = 0, pField = pArea->lpFields; uiIndex < pArea->uiFieldCount; uiIndex++, pField++ )
{
if( pField->uiType == HB_FT_STRING && ( pField->uiFlags && HB_FF_BINARY ) == 0 )
{
hb_cdpnTranslate( ( char * ) pBuffer + pArea->pFieldOffset[ uiIndex ], cdp_src, cdp_dest, pField->uiLen );
}
}
}
| dbf1.c | 4240 |
| STATIC ERRCODE | hb_dbfSort( DBFAREAP pArea, LPDBSORTINFO pSortInfo )
static ERRCODE hb_dbfSort( DBFAREAP pArea, LPDBSORTINFO pSortInfo )
{
ULONG ulRecNo;
USHORT uiCount;
BOOL bMoreRecords, bLimited, bValidRecord;
ERRCODE uiError;
DBQUICKSORT dbQuickSort;
BYTE * pBuffer;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfSort(%p, %p)", pArea, pSortInfo));
if( SELF_GOCOLD( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
if( !hb_dbQSortInit( &dbQuickSort, pSortInfo, pArea->uiRecordLen ) )
return FAILURE;
uiError = SUCCESS;
uiCount = 0;
pBuffer = dbQuickSort.pBuffer;
ulRecNo = 1;
if( pSortInfo->dbtri.dbsci.itmRecID )
{
uiError = SELF_GOTOID( ( AREAP ) pArea, pSortInfo->dbtri.dbsci.itmRecID );
bMoreRecords = bLimited = TRUE;
}
else if( pSortInfo->dbtri.dbsci.lNext )
{
ulRecNo = hb_itemGetNL( pSortInfo->dbtri.dbsci.lNext );
bLimited = TRUE;
bMoreRecords = ( ulRecNo > 0 );
}
else
{
if( !pSortInfo->dbtri.dbsci.itmCobWhile &&
( !pSortInfo->dbtri.dbsci.fRest ||
!hb_itemGetL( pSortInfo->dbtri.dbsci.fRest ) ) )
uiError = SELF_GOTOP( ( AREAP ) pArea );
bMoreRecords = TRUE;
bLimited = FALSE;
}
while( uiError == SUCCESS && !pArea->fEof && bMoreRecords )
{
if( pSortInfo->dbtri.dbsci.itmCobWhile )
{
if( SELF_EVALBLOCK( ( AREAP ) pArea, pSortInfo->dbtri.dbsci.itmCobWhile ) != SUCCESS )
{
hb_dbQSortExit( &dbQuickSort );
return FAILURE;
}
bMoreRecords = hb_itemGetL( pArea->valResult );
}
if( bMoreRecords && pSortInfo->dbtri.dbsci.itmCobFor )
{
if( SELF_EVALBLOCK( ( AREAP ) pArea, pSortInfo->dbtri.dbsci.itmCobFor ) != SUCCESS )
{
hb_dbQSortExit( &dbQuickSort );
return FAILURE;
}
bValidRecord = hb_itemGetL( pArea->valResult );
}
else
bValidRecord = bMoreRecords;
if( bValidRecord )
{
if( uiCount == dbQuickSort.uiMaxRecords )
{
if( !hb_dbQSortAdvance( &dbQuickSort, uiCount ) )
{
hb_dbQSortExit( &dbQuickSort );
return FAILURE;
}
pBuffer = dbQuickSort.pBuffer;
uiCount = 0;
}
/* Read record */
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
{
hb_dbQSortExit( &dbQuickSort );
return FAILURE;
}
/* Copy data */
memcpy( pBuffer, pArea->pRecord, pArea->uiRecordLen );
#ifndef HB_CDP_SUPPORT_OFF
if( pArea->cdPage != hb_vmCDP() )
{
hb_dbfTranslateRec( pArea, pBuffer, pArea->cdPage, hb_vmCDP() );
}
#endif
pBuffer += pArea->uiRecordLen;
uiCount++;
}
if( bMoreRecords && bLimited )
bMoreRecords = ( --ulRecNo > 0 );
if( bMoreRecords )
uiError = SELF_SKIP( ( AREAP ) pArea, 1 );
}
/* Copy last records */
if( uiCount > 0 )
{
if( !hb_dbQSortAdvance( &dbQuickSort, uiCount ) )
{
hb_dbQSortExit( &dbQuickSort );
return FAILURE;
}
}
/* Sort records */
hb_dbQSortComplete( &dbQuickSort );
return SUCCESS;
}
| dbf1.c | 4256 |
| STATIC ERRCODE | hb_dbfTrans( DBFAREAP pArea, LPDBTRANSINFO pTransInfo )
static ERRCODE hb_dbfTrans( DBFAREAP pArea, LPDBTRANSINFO pTransInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfTrans(%p, %p)", pArea, pTransInfo));
if( pTransInfo->uiFlags & DBTF_MATCH )
{
if( pArea->fHasMemo || pArea->cdPage != pTransInfo->lpaDest->cdPage )
pTransInfo->uiFlags &= ~DBTF_PUTREC;
else if( pArea->rddID == pTransInfo->lpaDest->rddID )
pTransInfo->uiFlags |= DBTF_PUTREC;
else
{
PHB_ITEM pPutRec = hb_itemPutL( NULL, FALSE );
if( SELF_INFO( ( AREAP ) pTransInfo->lpaDest, DBI_CANPUTREC, pPutRec ) != SUCCESS )
{
hb_itemRelease( pPutRec );
return FAILURE;
}
if( hb_itemGetL( pPutRec ) )
pTransInfo->uiFlags |= DBTF_PUTREC;
else
pTransInfo->uiFlags &= ~DBTF_PUTREC;
hb_itemRelease( pPutRec );
}
}
return SUPER_TRANS( ( AREAP ) pArea, pTransInfo );
}
| dbf1.c | 4378 |
| STATIC ERRCODE | hb_dbfZap( DBFAREAP pArea )
static ERRCODE hb_dbfZap( DBFAREAP pArea )
{
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfZap(%p)", pArea));
if( pArea->fReadonly )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_READONLY );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_READONLY ) );
hb_errPutSubCode( pError, EDBF_READONLY );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
if( pArea->fShared )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_SHARED );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_SHARED ) );
hb_errPutSubCode( pError, EDBF_SHARED );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
if( pArea->fTrigger )
{
if( !hb_dbfTriggerDo( pArea, EVENT_ZAP, 0, NULL ) )
return FAILURE;
}
if( SELF_GOCOLD( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
pArea->fUpdateHeader = TRUE;
pArea->ulRecCount = 0;
if( SELF_WRITEDBHEADER( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
if( SELF_GOTO( ( AREAP ) pArea, 0 ) != SUCCESS )
return FAILURE;
/* Zap memo file */
if( pArea->fHasMemo )
{
if( SELF_CREATEMEMFILE( ( AREAP ) pArea, NULL ) != SUCCESS )
return FAILURE;
}
return SUCCESS;
}
| dbf1.c | 4409 |
| STATIC ERRCODE | hb_dbfChildEnd( DBFAREAP pArea, LPDBRELINFO pRelInfo )
static ERRCODE hb_dbfChildEnd( DBFAREAP pArea, LPDBRELINFO pRelInfo )
{
ERRCODE uiError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfChildEnd(%p, %p)", pArea, pRelInfo));
if( pArea->lpdbPendingRel == pRelInfo )
uiError = SELF_FORCEREL( ( AREAP ) pArea );
else
uiError = SUCCESS;
SUPER_CHILDEND( ( AREAP ) pArea, pRelInfo );
return uiError;
}
| dbf1.c | 4464 |
| STATIC ERRCODE | hb_dbfChildStart( DBFAREAP pArea, LPDBRELINFO pRelInfo )
static ERRCODE hb_dbfChildStart( DBFAREAP pArea, LPDBRELINFO pRelInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfChildStart(%p, %p)", pArea, pRelInfo));
if( SELF_CHILDSYNC( ( AREAP ) pArea, pRelInfo ) != SUCCESS )
return FAILURE;
return SUPER_CHILDSTART( ( AREAP ) pArea, pRelInfo );
}
| dbf1.c | 4481 |
| STATIC ERRCODE | hb_dbfChildSync( DBFAREAP pArea, LPDBRELINFO pRelInfo )
static ERRCODE hb_dbfChildSync( DBFAREAP pArea, LPDBRELINFO pRelInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfChildSync(%p, %p)", pArea, pRelInfo));
/*
* !!! The side effect of calling GOCOLD() inside CHILDSYNC() is
* evaluation of index expressions (index KEY and FOR condition)
* when the pArea is not the current one - it means that the
* used RDD has to set proper work area before eval.
* IMHO GOCOLD() could be safely removed from this place but I'm not
* sure it's Clipper compatible - I will have to check it, Druzus.
*/
/*
* I've checked in CL5.3 Technical Reference Guide that only
* FORCEREL() should ensure that the work area buffer is not HOT
* and then call RELEVAL() - I hope it describes the CL5.3 DBF* RDDs
* behavior so I replicate it - the GOCOLD() is moved from CHILDSYNC()
* to FORCEREL(), Druzus.
*/
/*
* After some cleanups, the core DBF* code can work with GOCOLD() here
* and in FORCEREL() without any problems. Because calling GOCOLD() in
* FORCEREL() may interacts with badly written users RDD which inherits
* from DBF* RDDs and/or user triggers then I decided to keep it here,
* Druzus.
*/
if( SELF_GOCOLD( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
pArea->lpdbPendingRel = pRelInfo;
if( pArea->lpdbRelations )
return SELF_SYNCCHILDREN( ( AREAP ) pArea );
return SUCCESS;
}
| dbf1.c | 4493 |
| STATIC ERRCODE | hb_dbfForceRel( DBFAREAP pArea )
static ERRCODE hb_dbfForceRel( DBFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfForceRel(%p)", pArea));
if( pArea->lpdbPendingRel )
{
LPDBRELINFO lpdbPendingRel;
lpdbPendingRel = pArea->lpdbPendingRel;
pArea->lpdbPendingRel = NULL;
/* update buffers */
/* commented out - see comment above in CHILDSYNC() method, Druzus */
/* SELF_GOCOLD( ( AREAP ) pArea ); */
return SELF_RELEVAL( ( AREAP ) pArea, lpdbPendingRel );
}
return SUCCESS;
}
| dbf1.c | 4534 |
| STATIC ERRCODE | hb_dbfSetFilter( DBFAREAP pArea, LPDBFILTERINFO pFilterInfo )
static ERRCODE hb_dbfSetFilter( DBFAREAP pArea, LPDBFILTERINFO pFilterInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfSetFilter(%p, %p)", pArea, pFilterInfo));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
return SUPER_SETFILTER( ( AREAP ) pArea, pFilterInfo );
}
| dbf1.c | 4557 |
| STATIC ERRCODE | hb_dbfRawLock( DBFAREAP pArea, USHORT uiAction, ULONG ulRecNo )
static ERRCODE hb_dbfRawLock( DBFAREAP pArea, USHORT uiAction, ULONG ulRecNo )
{
ERRCODE uiErr = SUCCESS;
HB_FOFFSET ulPos, ulFlSize, ulRlSize;
int iDir;
BOOL fLck;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfRawLock(%p, %hu, %lu)", pArea, uiAction, ulRecNo));
if( pArea->fShared )
{
if( hb_dbfLockData( pArea, &ulPos, &ulFlSize, &ulRlSize, &iDir ) == FAILURE )
return FAILURE;
switch( uiAction )
{
case FILE_LOCK:
if( !pArea->fFLocked )
{
if( iDir < 0 )
fLck = hb_fileLock( pArea->pDataFile, ulPos - ulFlSize, ulFlSize, FL_LOCK );
else
fLck = hb_fileLock( pArea->pDataFile, ulPos + 1, ulFlSize, FL_LOCK );
if( !fLck )
uiErr = FAILURE;
else
pArea->fFLocked = TRUE;
}
break;
case FILE_UNLOCK:
if( pArea->fFLocked )
{
if( iDir < 0 )
fLck = hb_fileLock( pArea->pDataFile, ulPos - ulFlSize, ulFlSize, FL_UNLOCK );
else
fLck = hb_fileLock( pArea->pDataFile, ulPos + 1, ulFlSize, FL_UNLOCK );
if( !fLck )
uiErr = FAILURE;
pArea->fFLocked = FALSE;
}
break;
case REC_LOCK:
if( !pArea->fFLocked )
{
if( iDir < 0 )
fLck = hb_fileLock( pArea->pDataFile, ulPos - ulRecNo, ulRlSize, FL_LOCK );
else if( iDir == 2 )
fLck = hb_fileLock( pArea->pDataFile, ulPos + ( ulRecNo - 1 ) * pArea->uiRecordLen + pArea->uiHeaderLen, ulRlSize, FL_LOCK );
else
fLck = hb_fileLock( pArea->pDataFile, ulPos + ulRecNo, ulRlSize, FL_LOCK );
if( !fLck )
uiErr = FAILURE;
}
break;
case REC_UNLOCK:
if( !pArea->fFLocked )
{
if( iDir < 0 )
fLck = hb_fileLock( pArea->pDataFile, ulPos - ulRecNo, ulRlSize, FL_UNLOCK );
else if( iDir == 2 )
fLck = hb_fileLock( pArea->pDataFile, ulPos + ( ulRecNo - 1 ) * pArea->uiRecordLen + pArea->uiHeaderLen, ulRlSize, FL_UNLOCK );
else
fLck = hb_fileLock( pArea->pDataFile, ulPos + ulRecNo, ulRlSize, FL_UNLOCK );
if( !fLck )
uiErr = FAILURE;
}
break;
case APPEND_LOCK:
case HEADER_LOCK:
if( !pArea->fHeaderLocked )
{
for( ;; )
{
fLck = hb_fileLock( pArea->pDataFile, ulPos, 1, FL_LOCK | FLX_WAIT );
/* TODO: call special error handler (LOCKHANDLER) hiere if !fLck */
if( fLck )
break;
hb_releaseCPU();
}
if( !fLck )
uiErr = FAILURE;
else
pArea->fHeaderLocked = TRUE;
}
break;
case APPEND_UNLOCK:
case HEADER_UNLOCK:
if( pArea->fHeaderLocked )
{
if( !hb_fileLock( pArea->pDataFile, ulPos, 1, FL_UNLOCK ) )
uiErr = FAILURE;
pArea->fHeaderLocked = FALSE;
}
break;
}
}
return uiErr;
}
| dbf1.c | 4573 |
| STATIC ERRCODE | hb_dbfLock( DBFAREAP pArea, LPDBLOCKINFO pLockInfo )
static ERRCODE hb_dbfLock( DBFAREAP pArea, LPDBLOCKINFO pLockInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfLock(%p, %p)", pArea, pLockInfo));
if( pArea->fShared )
{
switch( pLockInfo->uiMethod )
{
case DBLM_EXCLUSIVE:
return hb_dbfLockRecord( pArea, 0, &pLockInfo->fResult, TRUE );
case DBLM_MULTIPLE:
return hb_dbfLockRecord( pArea, hb_itemGetNL( pLockInfo->itmRecID ),
&pLockInfo->fResult, FALSE );
case DBLM_FILE:
return hb_dbfLockFile( pArea, &pLockInfo->fResult );
default:
pLockInfo->fResult = FALSE;
}
}
else
pLockInfo->fResult = TRUE;
return SUCCESS;
}
| dbf1.c | 4683 |
| STATIC ERRCODE | hb_dbfUnLock( DBFAREAP pArea, PHB_ITEM pRecNo )
static ERRCODE hb_dbfUnLock( DBFAREAP pArea, PHB_ITEM pRecNo )
{
ERRCODE uiError;
ULONG ulRecNo;
HB_TRACE(HB_TR_DEBUG, ("dbfUnLock(%p, %p)", pArea, pRecNo));
ulRecNo = hb_itemGetNL( pRecNo );
uiError = SUCCESS;
if( pArea->fShared )
{
if( pArea->ulNumLocksPos > 0 )
{
/* Unlock all records? */
if( ulRecNo == 0 )
uiError = hb_dbfUnlockAllRecords( pArea );
else if( hb_dbfIsLocked( pArea, ulRecNo ) )
uiError = hb_dbfUnlockRecord( pArea, ulRecNo );
}
if( pArea->fFLocked )
{
uiError = hb_dbfUnlockFile( pArea );
}
}
return uiError;
}
| dbf1.c | 4714 |
| STATIC ERRCODE | hb_dbfCreateMemFile( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
static ERRCODE hb_dbfCreateMemFile( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
{
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfCreateMemFile(%p, %p)", pArea, pCreateInfo));
if( pCreateInfo )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_CREATE );
hb_errPutSubCode( pError, EDBF_DATATYPE );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CREATE ) );
hb_errPutFileName( pError, ( char * ) pCreateInfo->abName );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
}
pArea->fHasMemo = FALSE;
return FAILURE;
}
| dbf1.c | 4745 |
| STATIC ERRCODE | hb_dbfGetValueFile( DBFAREAP pArea, USHORT uiIndex, BYTE * szFile, USHORT uiMode )
static ERRCODE hb_dbfGetValueFile( DBFAREAP pArea, USHORT uiIndex, BYTE * szFile, USHORT uiMode )
{
USHORT uiError = SUCCESS;
LPFIELD pField;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetValueFile(%p, %hu, %s, %hu)", pArea, uiIndex, szFile, uiMode));
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
/* Read record */
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
return FAILURE;
if( --uiIndex >= pArea->uiFieldCount )
return FAILURE;
pField = pArea->lpFields + uiIndex;
if( pField->uiType == HB_FT_STRING )
{
PHB_FILE pFile;
pFile = hb_fileExtOpen( szFile, NULL, FO_WRITE | FO_EXCLUSIVE |
FXO_DEFAULTS | FXO_SHARELOCK |
( uiMode == FILEGET_APPEND ? FXO_APPEND : FXO_TRUNCATE ),
NULL, NULL );
if( !pFile )
{
uiError = uiMode != FILEGET_APPEND ? EDBF_CREATE : EDBF_OPEN_DBF;
}
else
{
if( hb_fileWriteAt( pFile, pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
pField->uiLen, hb_fileSize( pFile ) ) !=
( ULONG ) pField->uiLen )
{
uiError = EDBF_WRITE;
}
hb_fileClose( pFile );
}
}
else
{
uiError = EDBF_DATATYPE;
}
/* Exit if any error */
if( uiError != SUCCESS )
{
PHB_ITEM pError = hb_errNew();
hb_errPutGenCode( pError, hb_dbfGetEGcode( uiError ) );
hb_errPutDescription( pError, hb_langDGetErrorDesc( hb_dbfGetEGcode( uiError ) ) );
hb_errPutSubCode( pError, uiError );
hb_errPutFlags( pError, EF_CANDEFAULT );
if( uiError != EDBF_DATATYPE )
{
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutFileName( pError, ( char * ) szFile );
}
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
return SUCCESS;
}
| dbf1.c | 4768 |
| STATIC ERRCODE | hb_dbfOpenMemFile( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
static ERRCODE hb_dbfOpenMemFile( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
{
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfOpenMemFile(%p, %p)", pArea, pOpenInfo));
pError = hb_errNew();
hb_errPutGenCode( pError, EG_OPEN );
hb_errPutSubCode( pError, EDBF_OPEN_DBF );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_OPEN ) );
hb_errPutFileName( pError, ( char * ) pOpenInfo->abName );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
| dbf1.c | 4840 |
| STATIC ERRCODE | hb_dbfPutValueFile( DBFAREAP pArea, USHORT uiIndex, BYTE * szFile, USHORT uiMode )
static ERRCODE hb_dbfPutValueFile( DBFAREAP pArea, USHORT uiIndex, BYTE * szFile, USHORT uiMode )
{
USHORT uiError = SUCCESS, uiRead;
LPFIELD pField;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfPutValueFile(%p, %hu, %s, %hu)", pArea, uiIndex, szFile, uiMode));
HB_SYMBOL_UNUSED( uiMode );
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
}
/* Read record */
if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
return FAILURE;
if( --uiIndex >= pArea->uiFieldCount )
return FAILURE;
if( !pArea->fPositioned )
return FAILURE;
/* Buffer is hot? */
if( !pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == FAILURE )
return FAILURE;
pField = pArea->lpFields + uiIndex;
if( pField->uiType == HB_FT_STRING )
{
PHB_FILE pFile;
pFile = hb_fileExtOpen( szFile, NULL, FO_READ | FO_DENYNONE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( !pFile )
{
uiError = EDBF_OPEN_DBF;
}
else
{
uiRead = hb_fileReadAt( pFile, pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
pField->uiLen, 0 );
if( uiRead != ( USHORT ) FS_ERROR && uiRead < pField->uiLen )
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + uiRead,
' ', pField->uiLen - uiRead );
hb_fileClose( pFile );
}
}
else
{
uiError = EDBF_DATATYPE;
}
/* Exit if any error */
if( uiError != SUCCESS )
{
PHB_ITEM pError = hb_errNew();
hb_errPutGenCode( pError, hb_dbfGetEGcode( uiError ) );
hb_errPutDescription( pError, hb_langDGetErrorDesc( hb_dbfGetEGcode( uiError ) ) );
hb_errPutSubCode( pError, uiError );
hb_errPutFlags( pError, EF_CANDEFAULT );
if( uiError != EDBF_DATATYPE )
{
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutFileName( pError, ( char * ) szFile );
}
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
return SUCCESS;
}
| dbf1.c | 4859 |
| STATIC ERRCODE | hb_dbfReadDBHeader( DBFAREAP pArea )
static ERRCODE hb_dbfReadDBHeader( DBFAREAP pArea )
{
BOOL fRetry, fError;
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfReadDBHeader(%p)", pArea));
pError = NULL;
/* Try read */
do
{
fError = FALSE;
if( hb_fileReadAt( pArea->pDataFile, ( BYTE * ) &pArea->dbfHeader,
sizeof( DBFHEADER ), 0 ) != sizeof( DBFHEADER ) )
{
fError = TRUE;
}
else
{
pArea->fAutoInc = pArea->fModStamp =
pArea->fTableEncrypted = pArea->fHasMemo = FALSE;
pArea->bTableType = DB_DBF_STD;
pArea->bMemoType = DB_MEMO_NONE;
pArea->bCryptType = DB_CRYPT_NONE;
pArea->fHasTags = ( pArea->dbfHeader.bHasTags & 0x01 ) != 0;
switch( pArea->dbfHeader.bVersion )
{
case 0x31:
pArea->fAutoInc = TRUE;
case 0x30:
pArea->bTableType = DB_DBF_VFP;
if( pArea->dbfHeader.bHasTags & 0x02 )
{
pArea->bMemoType = DB_MEMO_FPT;
pArea->fHasMemo = TRUE;
}
break;
case 0x03:
break;
case 0x83:
pArea->fHasMemo = TRUE;
pArea->bMemoType = DB_MEMO_DBT;
break;
case 0xE5:
pArea->fHasMemo = TRUE;
pArea->bMemoType = DB_MEMO_SMT;
break;
case 0xF5:
pArea->fHasMemo = TRUE;
pArea->bMemoType = DB_MEMO_FPT;
break;
case 0x06:
pArea->fTableEncrypted = TRUE;
pArea->bCryptType = DB_CRYPT_SIX;
break;
case 0x86:
pArea->fTableEncrypted = TRUE;
pArea->fHasMemo = TRUE;
pArea->bCryptType = DB_CRYPT_SIX;
pArea->bMemoType = DB_MEMO_DBT;
break;
case 0xE6:
pArea->fHasMemo = TRUE;
pArea->fTableEncrypted = TRUE;
pArea->bCryptType = DB_CRYPT_SIX;
pArea->bMemoType = DB_MEMO_SMT;
break;
case 0xF6:
pArea->fHasMemo = TRUE;
pArea->fTableEncrypted = TRUE;
pArea->bCryptType = DB_CRYPT_SIX;
pArea->bMemoType = DB_MEMO_FPT;
break;
default:
fError = TRUE;
}
}
if( fError )
{
if( !pError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_CORRUPTION );
hb_errPutSubCode( pError, EDBF_CORRUPT );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CORRUPTION ) );
hb_errPutFileName( pError, pArea->szDataFileName );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
}
fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
}
else
fRetry = FALSE;
} while( fRetry );
if( pError )
hb_itemRelease( pError );
/* Read error? */
if( fError )
return FAILURE;
pArea->uiHeaderLen = HB_GET_LE_UINT16( pArea->dbfHeader.uiHeaderLen );
pArea->ulRecCount = HB_GET_LE_UINT32( pArea->dbfHeader.ulRecCount );
return SUCCESS;
}
| dbf1.c | 4937 |
| STATIC ERRCODE | hb_dbfWriteDBHeader( DBFAREAP pArea )
static ERRCODE hb_dbfWriteDBHeader( DBFAREAP pArea )
{
int iYear, iMonth, iDay;
BOOL fLck = FALSE;
ERRCODE errCode;
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfWriteDBHeader(%p)", pArea));
if( pArea->fReadonly )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_READONLY );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_READONLY ) );
hb_errPutSubCode( pError, EDBF_READONLY );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
pArea->dbfHeader.bHasTags = pArea->fHasTags ? 0x01 : 0x00;
if( pArea->bTableType == DB_DBF_VFP )
{
pArea->dbfHeader.bVersion = ( pArea->fAutoInc ? 0x31 : 0x30 );
if( pArea->fHasMemo && pArea->bMemoType == DB_MEMO_FPT )
pArea->dbfHeader.bHasTags |= 0x02;
}
else
{
pArea->dbfHeader.bVersion = 0x03;
if( pArea->fHasMemo )
{
if( pArea->bMemoType == DB_MEMO_DBT )
pArea->dbfHeader.bVersion = 0x83;
else if( pArea->bMemoType == DB_MEMO_FPT )
pArea->dbfHeader.bVersion = 0xF5;
else if( pArea->bMemoType == DB_MEMO_SMT )
pArea->dbfHeader.bVersion = 0xE5;
}
if( pArea->fTableEncrypted && pArea->bCryptType == DB_CRYPT_SIX )
pArea->dbfHeader.bVersion = ( pArea->dbfHeader.bVersion & 0xf0 ) | 0x06;
}
hb_dateToday( &iYear, &iMonth, &iDay );
pArea->dbfHeader.bYear = ( BYTE ) ( iYear - 1900 );
pArea->dbfHeader.bMonth = ( BYTE ) iMonth;
pArea->dbfHeader.bDay = ( BYTE ) iDay;
/* Update record count */
if( pArea->fShared )
{
if( !pArea->fHeaderLocked )
{
if( SELF_RAWLOCK( ( AREAP ) pArea, HEADER_LOCK, 0 ) != SUCCESS )
return FAILURE;
fLck = TRUE;
}
pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
}
else
{
/* Exclusive mode */
/* write eof mark */
HB_FOFFSET llOffset = ( HB_FOFFSET ) pArea->uiHeaderLen +
( HB_FOFFSET ) pArea->uiRecordLen *
( HB_FOFFSET ) pArea->ulRecCount;
hb_fileWriteAt( pArea->pDataFile, ( BYTE * ) "\032", 1, llOffset );
hb_fileTruncAt( pArea->pDataFile, llOffset + 1 );
}
HB_PUT_LE_UINT32( pArea->dbfHeader.ulRecCount, pArea->ulRecCount );
HB_PUT_LE_UINT16( pArea->dbfHeader.uiHeaderLen, pArea->uiHeaderLen );
HB_PUT_LE_UINT16( pArea->dbfHeader.uiRecordLen, pArea->uiRecordLen );
if( hb_fileWriteAt( pArea->pDataFile, ( BYTE * ) &pArea->dbfHeader,
sizeof( DBFHEADER ), 0 ) == sizeof( DBFHEADER ) )
{
errCode = SUCCESS;
}
else
{
errCode = FAILURE;
}
/* TODO: add RT error */
pArea->fDataFlush = TRUE;
pArea->fUpdateHeader = FALSE;
if( fLck )
{
if( SELF_RAWLOCK( ( AREAP ) pArea, HEADER_UNLOCK, 0 ) != SUCCESS )
return FAILURE;
}
if( errCode != SUCCESS )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_WRITE );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_WRITE ) );
hb_errPutSubCode( pError, EDBF_WRITE );
hb_errPutFileName( pError, pArea->szDataFileName );
hb_errPutOsCode( pError, hb_fsError() );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
}
return errCode;
}
| dbf1.c | 5060 |
| STATIC ERRCODE | hb_dbfDrop( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, ULONG ulConnect )
static ERRCODE hb_dbfDrop( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, ULONG ulConnect )
{
char szFileName[ _POSIX_PATH_MAX + 1 ], * szFile, * szExt;
PHB_ITEM pFileExt = NULL;
PHB_FNAME pFileName;
BOOL fTable = FALSE, fResult = FALSE;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfDrop(%p,%p,%p,%lu)", pRDD, pItemTable, pItemIndex, ulConnect));
szFile = hb_itemGetCPtr( pItemIndex );
if( !szFile[ 0 ] )
{
/* Try to delete index file */
szFile = hb_itemGetCPtr( pItemTable );
if( !szFile[ 0 ] )
return FALSE;
fTable = TRUE;
}
pFileName = hb_fsFNameSplit( szFile );
if( ! pFileName->szExtension && hb_setGetDefExtension() )
{
/* Add default extension if missing */
pFileExt = hb_itemPutC( NULL, NULL );
if( SELF_RDDINFO( pRDD, fTable ? RDDI_TABLEEXT : RDDI_ORDBAGEXT, ulConnect, pFileExt ) == SUCCESS )
pFileName->szExtension = hb_itemGetCPtr( pFileExt );
}
hb_fsFNameMerge( szFileName, pFileName );
hb_xfree( pFileName );
/* Use hb_spFile first to locate table which can be in differ path */
if( hb_spFile( ( BYTE * ) szFileName, ( BYTE * ) szFileName ) )
{
fResult = hb_fsDelete( ( BYTE * ) szFileName );
if( fResult && fTable )
{
/*
* Database table file has been deleted, now check if memo is
* supported and if yes then try to delete memo file if it exists
* in the same directory as table file
* hb_fsFNameSplit() repeated intentionally to respect
* the path set by hb_spFile()
*/
pFileName = hb_fsFNameSplit( szFileName );
pFileExt = hb_itemPutC( pFileExt, NULL );
if( SELF_RDDINFO( pRDD, RDDI_MEMOEXT, ulConnect, pFileExt ) == SUCCESS )
{
szExt = hb_itemGetCPtr( pFileExt );
if( szExt[ 0 ] )
{
pFileName->szExtension = szExt;
hb_fsFNameMerge( szFileName, pFileName );
hb_fsDelete( ( BYTE * ) szFileName );
}
}
/*
* and try to delete production index also if it exists
* in the same directory as table file
*/
pFileExt = hb_itemPutC( pFileExt, NULL );
if( SELF_RDDINFO( pRDD, RDDI_ORDSTRUCTEXT, ulConnect, pFileExt ) == SUCCESS )
{
szExt = hb_itemGetCPtr( pFileExt );
if( szExt[ 0 ] )
{
pFileName->szExtension = szExt;
hb_fsFNameMerge( szFileName, pFileName );
hb_fsDelete( ( BYTE * ) szFileName );
}
}
hb_xfree( pFileName );
}
}
if( pFileExt )
{
hb_itemRelease( pFileExt );
}
return fResult ? SUCCESS : FAILURE;
}
| dbf1.c | 5169 |
| STATIC ERRCODE | hb_dbfExists( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, ULONG ulConnect )
static ERRCODE hb_dbfExists( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, ULONG ulConnect )
{
char szFileName[ _POSIX_PATH_MAX + 1 ], * szFile;
PHB_ITEM pFileExt = NULL;
PHB_FNAME pFileName;
BOOL fTable = FALSE;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfExists(%p,%p,%p,%lu)", pRDD, pItemTable, pItemIndex, ulConnect));
szFile = hb_itemGetCPtr( pItemIndex );
if( !szFile[ 0 ] )
{
szFile = hb_itemGetCPtr( pItemTable );
if( !szFile[ 0 ] )
return FALSE;
fTable = TRUE;
}
pFileName = hb_fsFNameSplit( szFile );
if( ! pFileName->szExtension && hb_setGetDefExtension() )
{
pFileExt = hb_itemPutC( NULL, NULL );
if( SELF_RDDINFO( pRDD, fTable ? RDDI_TABLEEXT : RDDI_ORDBAGEXT, ulConnect, pFileExt ) == SUCCESS )
pFileName->szExtension = hb_itemGetCPtr( pFileExt );
}
hb_fsFNameMerge( szFileName, pFileName );
hb_xfree( pFileName );
if( pFileExt )
{
hb_itemRelease( pFileExt );
}
return hb_spFile( ( BYTE * ) szFileName, NULL ) ? SUCCESS : FAILURE;
}
| dbf1.c | 5251 |
| STATIC ERRCODE | hb_dbfInit( LPRDDNODE pRDD )
static ERRCODE hb_dbfInit( LPRDDNODE pRDD )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfInit(%p)", pRDD));
pRDD->lpvCargo = hb_xgrab( sizeof( DBFDATA ) );
memset( pRDD->lpvCargo, 0, sizeof( DBFDATA ) );
( ( LPDBFDATA ) pRDD->lpvCargo )->bTableType = DB_DBF_STD;
( ( LPDBFDATA ) pRDD->lpvCargo )->bCryptType = DB_CRYPT_NONE;
( ( LPDBFDATA ) pRDD->lpvCargo )->uiDirtyRead = HB_IDXREAD_CLEANMASK;
return SUCCESS;
}
| dbf1.c | 5287 |
| STATIC ERRCODE | hb_dbfExit( LPRDDNODE pRDD )
static ERRCODE hb_dbfExit( LPRDDNODE pRDD )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dbfExit(%p)", pRDD));
if( pRDD->lpvCargo )
{
LPDBFDATA pData = ( LPDBFDATA ) pRDD->lpvCargo;
if( pData->szTrigger )
hb_xfree( pData->szTrigger );
if( pData->szPendingTrigger )
hb_xfree( pData->szPendingTrigger );
if( pData->szPasswd )
hb_xfree( pData->szPasswd );
if( pData->szPendingPasswd )
hb_xfree( pData->szPendingPasswd );
hb_xfree( pRDD->lpvCargo );
pRDD->lpvCargo = NULL;
}
s_uiRddId = ( USHORT ) -1;
return SUCCESS;
}
| dbf1.c | 5301 |
| STATIC ERRCODE | hb_dbfRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem )
static ERRCODE hb_dbfRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem )
{
LPDBFDATA pData;
HB_TRACE(HB_TR_DEBUG, ("hb_dbfRddInfo(%p, %hu, %lu, %p)", pRDD, uiIndex, ulConnect, pItem));
pData = ( LPDBFDATA ) pRDD->lpvCargo;
switch( uiIndex )
{
case RDDI_ISDBF:
case RDDI_CANPUTREC:
case RDDI_LOCAL:
hb_itemPutL( pItem, TRUE );
break;
case RDDI_TABLEEXT:
{
char * szNew = hb_itemGetCPtr( pItem );
if( szNew[0] == '.' && szNew[1] )
szNew = hb_strdup( szNew );
else
szNew = NULL;
hb_itemPutC( pItem, pData->szTableExt[ 0 ] ? pData->szTableExt : DBF_TABLEEXT );
if( szNew )
{
hb_strncpy( pData->szTableExt, szNew, sizeof( pData->szTableExt ) - 1 );
hb_xfree( szNew );
}
break;
}
case RDDI_TABLETYPE:
{
int iType = hb_itemGetNI( pItem );
hb_itemPutNI( pItem, pData->bTableType ? pData->bTableType : DB_DBF_STD );
switch( iType )
{
case DB_DBF_STD: /* standard dBase/Clipper DBF file */
case DB_DBF_VFP: /* VFP DBF file */
pData->bTableType = iType;
}
break;
}
case RDDI_LOCKSCHEME:
{
int iScheme = hb_itemGetNI( pItem );
hb_itemPutNI( pItem, pData->bLockType ? pData->bLockType :
hb_setGetDBFLockScheme() );
switch( iScheme )
{
case DB_DBFLOCK_CLIP:
case DB_DBFLOCK_CL53:
case DB_DBFLOCK_CL53EXT:
case DB_DBFLOCK_VFP:
#ifndef HB_LONG_LONG_OFF
case DB_DBFLOCK_XHB64:
#endif
pData->bLockType = ( int ) iScheme;
}
break;
}
case RDDI_DIRTYREAD:
{
BOOL fDirty = ( pData->uiDirtyRead == HB_IDXREAD_DIRTYMASK );
if( HB_IS_LOGICAL( pItem ) )
{
pData->uiDirtyRead = hb_itemGetL( pItem ) ?
HB_IDXREAD_DIRTYMASK : HB_IDXREAD_CLEANMASK;
}
hb_itemPutL( pItem, fDirty );
break;
}
case RDDI_TRIGGER:
{
char * szTrigger = pData->szTrigger;
BOOL fFree = FALSE;
if( HB_IS_STRING( pItem ) )
{
fFree = TRUE;
pData->szTrigger = hb_itemGetCLen( pItem ) > 0 ?
hb_itemGetC( pItem ) : NULL;
}
if( fFree && szTrigger )
hb_itemPutCPtr2( pItem, szTrigger );
else
hb_itemPutC( pItem, szTrigger );
if( !szTrigger && !fFree )
return FAILURE;
break;
}
case RDDI_PENDINGTRIGGER:
if( HB_IS_STRING( pItem ) )
{
if( pData->szPendingTrigger )
{
hb_xfree( pData->szPendingTrigger );
pData->szPendingTrigger = NULL;
}
if( hb_itemGetCLen( pItem ) > 0 )
pData->szPendingTrigger = hb_itemGetC( pItem );
}
else if( pData->szPendingTrigger )
{
hb_itemPutCPtr2( pItem, pData->szPendingTrigger );
pData->szPendingTrigger = NULL;
}
else
return FAILURE;
break;
case RDDI_PASSWORD:
{
char * szPasswd = pData->szPasswd;
BOOL fFree = FALSE;
if( HB_IS_STRING( pItem ) )
{
fFree = TRUE;
pData->szPasswd = hb_itemGetCLen( pItem ) > 0 ?
hb_itemGetC( pItem ) : NULL;
}
if( fFree && szPasswd )
hb_itemPutCPtr2( pItem, szPasswd );
else
hb_itemPutC( pItem, szPasswd );
if( !szPasswd && !fFree )
return FAILURE;
break;
}
case RDDI_PENDINGPASSWORD:
if( HB_IS_STRING( pItem ) )
{
if( pData->szPendingPasswd )
{
hb_xfree( pData->szPendingPasswd );
pData->szPendingPasswd = NULL;
}
if( hb_itemGetCLen( pItem ) > 0 )
pData->szPendingPasswd = hb_itemGetC( pItem );
}
else if( pData->szPendingPasswd )
{
hb_itemPutCPtr2( pItem, pData->szPendingPasswd );
pData->szPendingPasswd = NULL;
}
else
return FAILURE;
break;
default:
return SUPER_RDDINFO( pRDD, uiIndex, ulConnect, pItem );
}
return SUCCESS;
}
HB_FUNC( _DBF ) { ; }
| dbf1.c | 5326 |
| } | HB_FUNC( DBF_GETFUNCTABLE )
HB_FUNC( DBF_GETFUNCTABLE )
{
RDDFUNCS * pTable;
USHORT * uiCount, uiRddId;
uiCount = ( USHORT * ) hb_parptr( 1 );
pTable = ( RDDFUNCS * ) hb_parptr( 2 );
uiRddId = hb_parni( 4 );
HB_TRACE(HB_TR_DEBUG, ("DBF_GETFUNCTABLE(%p, %p)", uiCount, pTable));
if( pTable )
{
ERRCODE errCode;
if( uiCount )
* uiCount = RDDFUNCSCOUNT;
errCode = hb_rddInherit( pTable, &dbfTable, &dbfSuper, NULL );
hb_retni( errCode );
if( errCode == SUCCESS )
{
/*
* we successfully register our RDD so now we can initialize it
* You may think that this place is RDD init statement, Druzus
*/
s_uiRddId = uiRddId;
}
}
else
hb_retni( FAILURE );
}
| dbf1.c | 5496 |
| STATIC VOID | hb_dbfRddInit( void * cargo )
static void hb_dbfRddInit( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
if( hb_rddRegister( "DBF", RDT_FULL ) > 1 )
{
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
}
}
| dbf1.c | 5536 |
| HB_INIT_SYMBOLS_BEGIN( | dbf1__InitSymbols )
HB_INIT_SYMBOLS_BEGIN( dbf1__InitSymbols )
{ "_DBF", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( _DBF )}, NULL },
{ "DBF_GETFUNCTABLE", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( DBF_GETFUNCTABLE )}, NULL }
HB_INIT_SYMBOLS_END( dbf1__InitSymbols )
HB_CALL_ON_STARTUP_BEGIN( _hb_dbf_rdd_init_ )
hb_vmAtInit( hb_dbfRddInit, NULL );
HB_CALL_ON_STARTUP_END( _hb_dbf_rdd_init_ )
#if defined( HB_PRAGMA_STARTUP )
#pragma startup dbf1__InitSymbols
#pragma startup _hb_dbf_rdd_init_
#elif defined( HB_MSC_STARTUP )
#if defined( HB_OS_WIN_64 )
#pragma section( HB_MSC_START_SEGMENT, long, read )
#endif
#pragma data_seg( HB_MSC_START_SEGMENT )
static HB_$INITSYM hb_vm_auto_dbf1__InitSymbols = dbf1__InitSymbols;
static HB_$INITSYM hb_vm_auto_dbf_rdd_init = _hb_dbf_rdd_init_;
| dbf1.c | 5546 |
| dbnubs.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | __DBSEEK(void)
HB_FUNC( __DBSEEK )
{
HB_FUNC_EXEC( DBSEEK );
}
| dbnubs.c | 81 |
| HB_FUNC | __DBSKIP(void)
HB_FUNC( __DBSKIP )
{
HB_FUNC_EXEC( DBSKIP );
}
| dbnubs.c | 86 |
| HB_FUNC | __DBGOTOP(void)
HB_FUNC( __DBGOTOP )
{
HB_FUNC_EXEC( DBGOTOP );
}
| dbnubs.c | 91 |
| HB_FUNC | __DBGOBOTTOM(void)
HB_FUNC( __DBGOBOTTOM )
{
HB_FUNC_EXEC( DBGOBOTTOM );
}
| dbnubs.c | 96 |
| HB_FUNC | __DBGOTO(void)
HB_FUNC( __DBGOTO )
{
HB_FUNC_EXEC( DBGOTO );
}
| dbnubs.c | 101 |
| HB_FUNC | __DBAPPEND(void)
HB_FUNC( __DBAPPEND )
{
HB_FUNC_EXEC( DBAPPEND );
}
| dbnubs.c | 106 |
| HB_FUNC | __DBDELETE(void)
HB_FUNC( __DBDELETE )
{
HB_FUNC_EXEC( DBDELETE );
}
| dbnubs.c | 111 |
| HB_FUNC | __DBRECALL(void)
HB_FUNC( __DBRECALL )
{
HB_FUNC_EXEC( DBRECALL );
}
| dbnubs.c | 116 |
| HB_FUNC | __DBCOMMIT(void)
HB_FUNC( __DBCOMMIT )
{
HB_FUNC_EXEC( DBCOMMITALL );
}
| dbnubs.c | 124 |
| HB_FUNC | __DBCOMMITALL(void)
HB_FUNC( __DBCOMMITALL )
{
HB_FUNC_EXEC( DBCOMMITALL );
}
| dbnubs.c | 129 |
| HB_FUNC | __DBUNLOCK(void)
HB_FUNC( __DBUNLOCK )
{
HB_FUNC_EXEC( DBUNLOCK );
}
| dbnubs.c | 134 |
| HB_FUNC | __DBUNLALL(void)
HB_FUNC( __DBUNLALL )
{
HB_FUNC_EXEC( DBUNLOCKALL );
}
| dbnubs.c | 139 |
| HB_FUNC | __DBSETFILTER(void)
HB_FUNC( __DBSETFILTER )
{
HB_FUNC_EXEC( DBSETFILTER );
}
| dbnubs.c | 144 |
| HB_FUNC | __DBCLEARRELATION(void)
HB_FUNC( __DBCLEARRELATION )
{
HB_FUNC_EXEC( DBCLEARRELATION );
}
| dbnubs.c | 149 |
| HB_FUNC | __DBSETRELATION(void)
HB_FUNC( __DBSETRELATION )
{
HB_FUNC_EXEC( DBSETRELATION );
}
| dbnubs.c | 154 |
| HB_FUNC | __DBREINDEX(void)
HB_FUNC( __DBREINDEX )
{
HB_FUNC_EXEC( DBREINDEX );
}
| dbnubs.c | 159 |
| HB_FUNC | __DBCREATINDEX(void)
HB_FUNC( __DBCREATINDEX )
{
HB_FUNC_EXEC( DBCREATEINDEX );
}
| dbnubs.c | 164 |
| HB_FUNC | __DBCLEARINDEX(void)
HB_FUNC( __DBCLEARINDEX )
{
HB_FUNC_EXEC( DBCLEARINDEX );
}
| dbnubs.c | 169 |
| HB_FUNC | __DBSETINDEX(void)
HB_FUNC( __DBSETINDEX )
{
HB_FUNC_EXEC( DBSETINDEX );
}
| dbnubs.c | 174 |
| HB_FUNC | __DBSETORDER(void)
HB_FUNC( __DBSETORDER )
{
HB_FUNC_EXEC( DBSETORDER );
}
| dbnubs.c | 179 |
| HB_FUNC | __DBCLOSEAREA(void)
HB_FUNC( __DBCLOSEAREA )
{
HB_FUNC_EXEC( DBCLOSEALL );
}
| dbnubs.c | 184 |
| HB_FUNC | __DBCLOSE(void)
HB_FUNC( __DBCLOSE )
{
HB_FUNC_EXEC( DBCLOSEAREA );
}
| dbnubs.c | 189 |
| HB_FUNC | __DBUSE(void)
HB_FUNC( __DBUSE )
{
HB_FUNC_EXEC( DBUSEAREA );
}
| dbnubs.c | 194 |
| HB_FUNC | __DBSELECT(void)
HB_FUNC( __DBSELECT )
{
HB_FUNC_EXEC( DBSELECTAREA );
}
| dbnubs.c | 199 |
| dbsql.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_flushFBuffer( PHB_FILEBUF pFileBuf )
static void hb_flushFBuffer( PHB_FILEBUF pFileBuf )
{
if( pFileBuf->ulPos > 0 )
{
hb_fsWriteLarge( pFileBuf->hFile, pFileBuf->pBuf, pFileBuf->ulPos );
pFileBuf->ulPos = 0;
}
}
| dbsql.c | 75 |
| STATIC VOID | hb_addToFBuffer( PHB_FILEBUF pFileBuf, char ch )
static void hb_addToFBuffer( PHB_FILEBUF pFileBuf, char ch )
{
if( pFileBuf->ulPos == pFileBuf->ulSize )
hb_flushFBuffer( pFileBuf );
pFileBuf->pBuf[ pFileBuf->ulPos++ ] = ( BYTE ) ch;
}
| dbsql.c | 84 |
| STATIC VOID | hb_addStrnToFBuffer( PHB_FILEBUF pFileBuf, const char * str, ULONG ulSize )
static void hb_addStrnToFBuffer( PHB_FILEBUF pFileBuf, const char * str, ULONG ulSize )
{
ULONG ulPos = 0;
while( ulPos < ulSize )
{
if( pFileBuf->ulPos == pFileBuf->ulSize )
hb_flushFBuffer( pFileBuf );
pFileBuf->pBuf[ pFileBuf->ulPos++ ] = ( BYTE ) str[ ulPos++ ];
}
}
| dbsql.c | 91 |
| STATIC VOID | hb_addStrToFBuffer( PHB_FILEBUF pFileBuf, const char * szStr )
static void hb_addStrToFBuffer( PHB_FILEBUF pFileBuf, const char * szStr )
{
while( *szStr )
{
if( pFileBuf->ulPos == pFileBuf->ulSize )
hb_flushFBuffer( pFileBuf );
pFileBuf->pBuf[ pFileBuf->ulPos++ ] = ( BYTE ) *szStr++;
}
}
| dbsql.c | 102 |
| STATIC VOID | hb_destroyFBuffer( PHB_FILEBUF pFileBuf )
static void hb_destroyFBuffer( PHB_FILEBUF pFileBuf )
{
hb_flushFBuffer( pFileBuf );
if( pFileBuf->pBuf )
hb_xfree( pFileBuf->pBuf );
hb_xfree( pFileBuf );
}
| dbsql.c | 112 |
| STATIC PHB_FILEBUF | hb_createFBuffer( HB_FHANDLE hFile, ULONG ulSize )
static PHB_FILEBUF hb_createFBuffer( HB_FHANDLE hFile, ULONG ulSize )
{
PHB_FILEBUF pFileBuf = ( PHB_FILEBUF )hb_xgrab( sizeof( HB_FILEBUF ) );
pFileBuf->hFile = hFile;
pFileBuf->pBuf = ( BYTE * )hb_xgrab( ulSize );
pFileBuf->ulSize = ulSize;
pFileBuf->ulPos = 0;
return pFileBuf;
}
| dbsql.c | 120 |
| STATIC BOOL | hb_exportBufSqlVar( PHB_FILEBUF pFileBuf, PHB_ITEM pValue, const char * szDelim, const char * szEsc )
static BOOL hb_exportBufSqlVar( PHB_FILEBUF pFileBuf, PHB_ITEM pValue,
const char * szDelim, const char * szEsc )
{
switch( hb_itemType( pValue ) )
{
case HB_IT_STRING:
{
ULONG ulLen = hb_itemGetCLen( pValue ), ulCnt = 0;
const char *szVal = hb_itemGetCPtr( pValue );
hb_addStrToFBuffer( pFileBuf, szDelim );
while( ulLen && HB_ISSPACE( szVal[ ulLen - 1 ] ) )
ulLen--;
while( *szVal && ulCnt++ < ulLen )
{
if( *szVal == *szDelim || *szVal == *szEsc )
hb_addToFBuffer( pFileBuf, *szEsc );
if( ( UCHAR ) *szVal >= 32 )
hb_addToFBuffer( pFileBuf, *szVal );
else
{
/* printf( "%d %c", *szVal, *szVal ); */
}
szVal++;
}
hb_addStrToFBuffer( pFileBuf, szDelim );
break;
}
case HB_IT_DATE:
{
char szDate[9];
hb_addStrToFBuffer( pFileBuf, szDelim );
hb_itemGetDS( pValue, szDate );
if( szDate[0] == ' ' )
{
hb_addStrToFBuffer( pFileBuf, "0100-01-01" );
}
else
{
hb_addStrnToFBuffer( pFileBuf, &szDate[0], 4 );
hb_addToFBuffer( pFileBuf, '-' );
hb_addStrnToFBuffer( pFileBuf, &szDate[4], 2 );
hb_addToFBuffer( pFileBuf, '-' );
hb_addStrnToFBuffer( pFileBuf, &szDate[6], 2 );
}
hb_addStrToFBuffer( pFileBuf, szDelim );
break;
}
case HB_IT_LOGICAL:
hb_addStrToFBuffer( pFileBuf, szDelim );
hb_addToFBuffer( pFileBuf, hb_itemGetCPtr( pValue ) ? 'Y' : 'N' );
hb_addStrToFBuffer( pFileBuf, szDelim );
break;
case HB_IT_INTEGER:
case HB_IT_LONG:
case HB_IT_DOUBLE:
{
char szResult[ HB_MAX_DOUBLE_LENGTH ];
int iSize, iWidth, iDec;
hb_itemGetNLen( pValue, &iWidth, &iDec );
iSize = ( iDec > 0 ? iWidth + 1 + iDec : iWidth );
if( hb_itemStrBuf( szResult, pValue, iSize, iDec ) )
{
int iPos = 0;
while( iSize && HB_ISSPACE( szResult[ iPos ] ) )
{
iPos++;
iSize--;
}
hb_addStrnToFBuffer( pFileBuf, &szResult[ iPos ], iSize );
}
else
hb_addToFBuffer( pFileBuf, '0' );
break;
}
/* an "M" field or the other, might be a "V" in SixDriver */
default:
/* We do not want MEMO contents */
return FALSE;
}
return TRUE;
}
| dbsql.c | 132 |
| STATIC ULONG | hb_db2Sql( AREAP pArea, PHB_ITEM pFields, HB_LONG llNext, PHB_ITEM pWhile, PHB_ITEM pFor, const char * szDelim, char * szSep, const char * szEsc, const char * szTable, HB_FHANDLE hFile, BOOL fInsert, BOOL fRecno )
static ULONG hb_db2Sql( AREAP pArea, PHB_ITEM pFields, HB_LONG llNext,
PHB_ITEM pWhile, PHB_ITEM pFor,
const char * szDelim, char * szSep, const char * szEsc,
const char * szTable, HB_FHANDLE hFile,
BOOL fInsert, BOOL fRecno )
{
PHB_FILEBUF pFileBuf;
ULONG ulRecords = 0;
USHORT uiFields = 0, ui;
PHB_ITEM pTmp;
BOOL fWriteSep = FALSE;
const char * szNewLine = hb_conNewLine();
char * szInsert = NULL;
BOOL fEof = TRUE;
BOOL fNoFieldPassed = ( pFields == NULL || hb_arrayLen( pFields ) == 0 );
if( SELF_FIELDCOUNT( pArea, &uiFields ) != SUCCESS )
return 0;
if( fInsert && szTable )
szInsert = hb_xstrcpy( NULL, "INSERT INTO ", szTable, " VALUES ( ", NULL );
pFileBuf = hb_createFBuffer( hFile, HB_FILE_BUF_SIZE );
pTmp = hb_itemNew( NULL );
while( llNext-- > 0 )
{
if( pWhile )
{
if( SELF_EVALBLOCK( pArea, pWhile ) != SUCCESS ||
! hb_itemGetL( pArea->valResult ) )
break;
}
if( SELF_EOF( pArea, &fEof ) != SUCCESS || fEof )
break;
if( pFor )
{
if( SELF_EVALBLOCK( pArea, pFor ) != SUCCESS )
break;
}
if( !pFor || hb_itemGetL( pArea->valResult ) )
{
++ulRecords;
if( szInsert )
hb_addStrToFBuffer( pFileBuf, szInsert );
if( fRecno )
{
ULONG ulRec = ulRecords;
char szRecno[ 13 ], * szVal;
szVal = szRecno + sizeof( szRecno );
*--szVal = 0;
do
{
*--szVal = ( char ) ( ulRec % 10 ) + '0';
ulRec /= 10;
}
while( ulRec );
hb_addStrToFBuffer( pFileBuf, szVal );
hb_addStrToFBuffer( pFileBuf, szSep );
}
if( fNoFieldPassed )
{
for( ui = 1; ui <= uiFields; ui ++ )
{
if( SELF_GETVALUE( pArea, ui, pTmp ) != SUCCESS )
break;
if( fWriteSep )
hb_addStrToFBuffer( pFileBuf, szSep );
fWriteSep = hb_exportBufSqlVar( pFileBuf, pTmp, szDelim, szEsc );
}
if( ui <= uiFields )
break;
}
else
{
/* TODO: exporting only some fields */
}
if( szInsert )
hb_addStrToFBuffer( pFileBuf, " );" );
hb_addStrToFBuffer( pFileBuf, szNewLine );
fWriteSep = FALSE;
}
if( SELF_SKIP( pArea, 1 ) != SUCCESS )
break;
if( ( llNext % 10000 ) == 0 )
hb_inkeyPoll();
}
if( szInsert )
hb_xfree( szInsert );
hb_destroyFBuffer( pFileBuf );
hb_itemRelease( pTmp );
/* Writing EOF */
/* hb_fsWrite( hFile, ( BYTE * ) "\x1A", 1 ); */
return ulRecords;
}
| dbsql.c | 222 |
| HB_FUNC | __DBSQL(void)
HB_FUNC( __DBSQL )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
BOOL fExport = hb_parl( 1 );
char * szFileName = hb_parc( 2 );
char * szTable = hb_parc( 3 );
PHB_ITEM pFields = hb_param( 4, HB_IT_ARRAY );
PHB_ITEM pFor = hb_param( 5, HB_IT_BLOCK );
PHB_ITEM pWhile = hb_param( 6, HB_IT_BLOCK );
PHB_ITEM pNext = hb_param( 7, HB_IT_NUMERIC );
PHB_ITEM pRecord = ISNIL( 8 ) ? NULL : hb_param( 8, HB_IT_ANY );
BOOL fRest = pWhile != NULL || ( ISLOG( 9 ) && hb_parl( 9 ) );
BOOL fAppend = ISLOG( 10 ) && hb_parl( 10 );
BOOL fInsert = ISLOG( 11 ) && hb_parl( 11 );
BOOL fRecno = ISLOG( 12 ) && hb_parl( 12 );
char * szSep = hb_parcx( 13 );
char * szDelim = hb_parcx( 14 );
char * szEsc = hb_parcx( 15 );
HB_LONG llNext = HB_LONG_MAX;
HB_FHANDLE hFile;
ERRCODE errCode;
if( ! szFileName )
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBCMDBADPARAMETER, NULL, HB_ERR_FUNCNAME );
else if( fExport ) /* COPY TO SQL */
{
PHB_ITEM pError = NULL;
BOOL fRetry;
/* Try to create Dat file */
do
{
hFile = hb_fsExtOpen( ( BYTE * ) szFileName, NULL,
( fAppend ? 0 : FXO_TRUNCATE ) |
FO_READWRITE | FO_EXCLUSIVE |
FXO_DEFAULTS | FXO_SHARELOCK,
NULL, pError );
if( hFile == FS_ERROR )
{
if( !pError )
{
pError = hb_errNew();
hb_errPutSeverity( pError, ES_ERROR );
if( fAppend )
{
hb_errPutGenCode( pError, EG_OPEN );
hb_errPutSubCode( pError, EDBF_OPEN_DBF );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_OPEN ) );
}
else
{
hb_errPutGenCode( pError, EG_CREATE );
hb_errPutSubCode( pError, EDBF_CREATE_DBF );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CREATE ) );
}
hb_errPutFileName( pError, szFileName );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
hb_errPutSubSystem( pError, "DBF2SQL" );
}
hb_errPutOsCode( pError, hb_fsError() );
fRetry = hb_errLaunch( pError ) == E_RETRY;
}
else
fRetry = FALSE;
}
while( fRetry );
if( pError )
hb_itemRelease( pError );
if( hFile != FS_ERROR )
{
if( fAppend )
hb_fsSeekLarge( hFile, 0, FS_END );
errCode = SUCCESS;
if( pRecord )
{
errCode = SELF_GOTOID( pArea, pRecord );
}
else if( pNext )
{
llNext = hb_itemGetNInt( pNext );
}
else if( !fRest )
{
errCode = SELF_GOTOP( pArea );
}
if( errCode == SUCCESS )
{
hb_retnint( hb_db2Sql( pArea, pFields, llNext, pWhile, pFor,
szDelim, szSep, szEsc,
szTable, hFile, fInsert, fRecno ) );
}
hb_fsClose( hFile );
}
}
else
{
/* TODO: import code */
}
}
else
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
}
| dbsql.c | 331 |
| delim1.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_delimInitArea( DELIMAREAP pArea, char * szFileName )
static void hb_delimInitArea( DELIMAREAP pArea, char * szFileName )
{
char * szEol;
/* Allocate only after succesfully open file */
pArea->szFileName = hb_strdup( szFileName );
/* set line separator: EOL */
szEol = hb_setGetEOL();
if( !szEol || !szEol[ 0 ] )
szEol = hb_conNewLine();
pArea->szEol = hb_strdup( szEol );
pArea->uiEolLen = strlen( pArea->szEol );
/* allocate record buffer, one additional byte is for deleted flag */
pArea->pRecord = ( BYTE * ) hb_xgrab( pArea->uiRecordLen + 1 );
/* pseudo deleted flag */
*pArea->pRecord++ = ' ';
/* Allocate IO buffer */
pArea->ulBufferSize += pArea->uiEolLen;
pArea->pBuffer = ( BYTE * ) hb_xgrab( pArea->ulBufferSize );
pArea->ulRecCount = 0;
pArea->ulFileSize = 0;
pArea->ulBufferRead = pArea->ulBufferIndex = 0;
}
| delim1.c | 71 |
| STATIC VOID | hb_delimClearRecordBuffer( DELIMAREAP pArea )
static void hb_delimClearRecordBuffer( DELIMAREAP pArea )
{
memset( pArea->pRecord, ' ', pArea->uiRecordLen );
}
| delim1.c | 99 |
| STATIC ULONG | hb_delimEncodeBuffer( DELIMAREAP pArea )
static ULONG hb_delimEncodeBuffer( DELIMAREAP pArea )
{
ULONG ulSize;
USHORT uiField, uiLen;
LPFIELD pField;
BYTE * pBuffer, * pFieldBuf;
HB_TRACE(HB_TR_DEBUG, ("hb_delimEncodeBuffer(%p)", pArea));
/* mark the read buffer as empty */
pArea->ulBufferRead = pArea->ulBufferIndex = 0;
pBuffer = pArea->pBuffer;
ulSize = 0;
for( uiField = 0; uiField < pArea->uiFieldCount; ++uiField )
{
pField = pArea->lpFields + uiField;
pFieldBuf = pArea->pRecord + pArea->pFieldOffset[ uiField ];
if( ulSize )
pBuffer[ ulSize++ ] = pArea->cSeparator;
switch( pField->uiType )
{
case HB_FT_STRING:
uiLen = pField->uiLen;
while( uiLen && pFieldBuf[ uiLen - 1 ] == ' ' )
--uiLen;
if( pArea->cDelim )
{
pBuffer[ ulSize++ ] = pArea->cDelim;
memcpy( pBuffer + ulSize, pFieldBuf, uiLen );
ulSize += uiLen;
pBuffer[ ulSize++ ] = pArea->cDelim;
}
else
{
memcpy( pBuffer + ulSize, pFieldBuf, uiLen );
ulSize += uiLen;
}
break;
case HB_FT_LOGICAL:
pBuffer[ ulSize++ ] = ( *pFieldBuf == 'T' || *pFieldBuf == 't' ||
*pFieldBuf == 'Y' || *pFieldBuf == 'y' ) ?
'T' : 'F';
break;
case HB_FT_DATE:
uiLen = 0;
while( uiLen < 8 && pFieldBuf[ uiLen ] == ' ' )
++uiLen;
if( uiLen < 8 )
{
memcpy( pBuffer + ulSize, pFieldBuf, 8 );
ulSize += 8;
}
break;
case HB_FT_LONG:
uiLen = 0;
while( uiLen < pField->uiLen && pFieldBuf[ uiLen ] == ' ' )
++uiLen;
if( uiLen < pField->uiLen )
{
memcpy( pBuffer + ulSize, pFieldBuf + uiLen, pField->uiLen - uiLen );
ulSize += pField->uiLen - uiLen;
}
else
{
pBuffer[ ulSize++ ] = '0';
if( pField->uiDec )
{
pBuffer[ ulSize++ ] = '.';
memset( pBuffer + ulSize, '0', pField->uiDec );
ulSize += pField->uiDec;
}
}
break;
case HB_FT_MEMO:
default:
if( ulSize )
--ulSize;
break;
}
}
memcpy( pBuffer + ulSize, pArea->szEol, pArea->uiEolLen );
ulSize += pArea->uiEolLen;
return ulSize;
}
| delim1.c | 104 |
| STATIC INT | hb_delimNextChar( DELIMAREAP pArea )
static int hb_delimNextChar( DELIMAREAP pArea )
{
if( pArea->ulBufferIndex + pArea->uiEolLen >= pArea->ulBufferRead &&
( pArea->ulBufferRead == 0 ||
pArea->ulBufferRead >= pArea->ulBufferSize - 1 ) )
{
ULONG ulLeft = pArea->ulBufferRead - pArea->ulBufferIndex;
if( ulLeft )
memcpy( pArea->pBuffer,
pArea->pBuffer + pArea->ulBufferIndex, ulLeft );
pArea->ulBufferStart += pArea->ulBufferIndex;
pArea->ulBufferIndex = 0;
pArea->ulBufferRead = hb_fileReadAt( pArea->pFile,
pArea->pBuffer + ulLeft,
pArea->ulBufferSize - ulLeft,
pArea->ulBufferStart + ulLeft );
if( pArea->ulBufferRead > 0 &&
pArea->pBuffer[ pArea->ulBufferRead + ulLeft - 1 ] == '\032' )
pArea->ulBufferRead--;
pArea->ulBufferRead += ulLeft;
}
if( pArea->ulBufferIndex + pArea->uiEolLen <= pArea->ulBufferRead &&
memcmp( pArea->pBuffer + pArea->ulBufferIndex,
pArea->szEol, pArea->uiEolLen ) == 0 )
{
pArea->ulBufferIndex += pArea->uiEolLen;
pArea->ulNextOffset = pArea->ulBufferStart + pArea->ulBufferIndex;
return -1;
}
else if( pArea->ulBufferIndex < pArea->ulBufferRead )
{
return pArea->pBuffer[ pArea->ulBufferIndex++ ];
}
pArea->ulNextOffset = ( HB_FOFFSET ) -1;
return -2;
}
| delim1.c | 196 |
| STATIC ERRCODE | hb_delimReadRecord( DELIMAREAP pArea )
static ERRCODE hb_delimReadRecord( DELIMAREAP pArea )
{
USHORT uiField, uiLen, uiSize;
HB_TYPE uiType;
LPFIELD pField;
BYTE * pFieldBuf, buffer[ 256 ];
char cStop;
int ch = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_delimReadRecord(%p)", pArea));
if( pArea->ulBufferStart <= pArea->ulRecordOffset &&
pArea->ulBufferStart + ( HB_FOFFSET ) pArea->ulBufferRead > pArea->ulRecordOffset )
{
pArea->ulBufferIndex = ( ULONG ) ( pArea->ulRecordOffset - pArea->ulBufferStart );
}
else
{
pArea->ulBufferStart = pArea->ulRecordOffset;
pArea->ulBufferRead = pArea->ulBufferIndex = 0;
}
/* clear the record buffer */
hb_delimClearRecordBuffer( pArea );
for( uiField = 0; uiField < pArea->uiFieldCount; ++uiField )
{
pField = pArea->lpFields + uiField;
uiType = pField->uiType;
if( uiType == HB_FT_STRING || uiType == HB_FT_LOGICAL ||
uiType == HB_FT_DATE || uiType == HB_FT_LONG )
{
uiSize = 0;
uiLen = pField->uiLen;
pFieldBuf = pArea->pRecord + pArea->pFieldOffset[ uiField ];
/* ignore leading spaces */
do
ch = hb_delimNextChar( pArea );
while( ch == ' ' );
/* set the stop character */
if( pArea->cDelim && ch == pArea->cDelim )
{
cStop = pArea->cDelim;
ch = hb_delimNextChar( pArea );
}
else
cStop = pArea->cSeparator;
/*
* Clipper uses differ rules for character fields, they
* can be terminated only with valid stop character, when
* other fields also by length
*/
if( pField->uiType == HB_FT_STRING )
{
while( ch >= 0 && ch != cStop )
{
if( uiSize < uiLen )
pFieldBuf[ uiSize++ ] = ( BYTE ) ch;
ch = hb_delimNextChar( pArea );
}
}
else
{
while( ch >= 0 && ch != cStop && uiSize < uiLen )
{
buffer[ uiSize++ ] = ( BYTE ) ch;
ch = hb_delimNextChar( pArea );
}
buffer[ uiSize ] = '\0';
if( pField->uiType == HB_FT_LOGICAL )
{
*pFieldBuf = ( *buffer == 'T' || *buffer == 't' ||
*buffer == 'Y' || *buffer == 'y' ) ? 'T' : 'F';
}
else if( pField->uiType == HB_FT_DATE )
{
if( uiSize == 8 && hb_dateEncStr( ( char * ) buffer ) != 0 )
memcpy( pFieldBuf, buffer, 8 );
}
else
{
HB_LONG lVal;
double dVal;
BOOL fDbl;
fDbl = hb_strnToNum( (const char *) buffer, uiSize, &lVal, &dVal );
if( fDbl )
pArea->valResult = hb_itemPutNDLen( pArea->valResult, dVal,
uiLen - pField->uiDec - 1, pField->uiDec );
else
pArea->valResult = hb_itemPutNIntLen( pArea->valResult,
lVal, uiLen );
hb_itemStrBuf( ( char * ) buffer, pArea->valResult, uiLen, pField->uiDec );
/* TODO: RT error on width range */
memcpy( pFieldBuf, buffer, uiLen );
}
}
/* ignore all character to the next field separator */
while( ch >= 0 && ch != pArea->cSeparator )
ch = hb_delimNextChar( pArea );
/* stop reading on EOL */
if( ch < 0 )
break;
}
}
/* ignore all character to the end of line */
while( ch >= 0 )
ch = hb_delimNextChar( pArea );
if( ch == -2 &&
pArea->ulRecordOffset == ( HB_FOFFSET ) ( pArea->ulBufferStart +
pArea->ulBufferIndex ) )
{
pArea->fEof = TRUE;
pArea->fPositioned = FALSE;
}
else
{
pArea->fEof = FALSE;
pArea->fPositioned = TRUE;
}
return SUCCESS;
}
| delim1.c | 236 |
| STATIC ERRCODE | hb_delimNextRecord( DELIMAREAP pArea )
static ERRCODE hb_delimNextRecord( DELIMAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimNextRecord(%p)", pArea));
if( pArea->fPositioned )
{
if( pArea->ulNextOffset == ( HB_FOFFSET ) -1 )
{
pArea->fEof = TRUE;
pArea->fPositioned = FALSE;
hb_delimClearRecordBuffer( pArea );
}
else
{
pArea->ulRecNo++;
pArea->ulRecordOffset = pArea->ulNextOffset;
return hb_delimReadRecord( pArea );
}
}
return SUCCESS;
}
| delim1.c | 371 |
| STATIC ERRCODE | hb_delimGoTop( DELIMAREAP pArea )
static ERRCODE hb_delimGoTop( DELIMAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimGoTop(%p)", pArea));
if( SELF_GOCOLD( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
pArea->fTop = TRUE;
pArea->fBottom = FALSE;
pArea->ulRecordOffset = 0;
pArea->ulRecNo = 1;
if( hb_delimReadRecord( pArea ) != SUCCESS )
return FAILURE;
return SELF_SKIPFILTER( ( AREAP ) pArea, 1 );
}
| delim1.c | 397 |
| STATIC ERRCODE | hb_delimSkipRaw( DELIMAREAP pArea, LONG lToSkip )
static ERRCODE hb_delimSkipRaw( DELIMAREAP pArea, LONG lToSkip )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimSkipRaw(%p,%ld)", pArea, lToSkip));
if( SELF_GOCOLD( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
if( lToSkip != 1 )
return FAILURE;
else
return hb_delimNextRecord( pArea );
}
| delim1.c | 418 |
| STATIC ERRCODE | hb_delimDeleted( DELIMAREAP pArea, BOOL * pDeleted )
static ERRCODE hb_delimDeleted( DELIMAREAP pArea, BOOL * pDeleted )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimDeleted(%p,%p)", pArea, pDeleted));
HB_SYMBOL_UNUSED( pArea );
* pDeleted = FALSE;
return SUCCESS;
}
| delim1.c | 434 |
| STATIC ERRCODE | hb_delimRecCount( DELIMAREAP pArea, ULONG * pRecCount )
static ERRCODE hb_delimRecCount( DELIMAREAP pArea, ULONG * pRecCount )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimRecCount(%p,%p)", pArea, pRecCount));
* pRecCount = pArea->ulRecCount;
return SUCCESS;
}
| delim1.c | 448 |
| STATIC ERRCODE | hb_delimRecNo( DELIMAREAP pArea, ULONG * pulRecNo )
static ERRCODE hb_delimRecNo( DELIMAREAP pArea, ULONG * pulRecNo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimRecNo(%p,%p)", pArea, pulRecNo));
*pulRecNo = pArea->ulRecNo;
return SUCCESS;
}
| delim1.c | 460 |
| STATIC ERRCODE | hb_delimRecId( DELIMAREAP pArea, PHB_ITEM pRecNo )
static ERRCODE hb_delimRecId( DELIMAREAP pArea, PHB_ITEM pRecNo )
{
ERRCODE errCode;
ULONG ulRecNo;
HB_TRACE(HB_TR_DEBUG, ("hb_delimRecId(%p,%p)", pArea, pRecNo));
errCode = SELF_RECNO( ( AREAP ) pArea, &ulRecNo );
#ifdef HB_C52_STRICT
/* this is for strict Clipper compatibility but IMHO Clipper should not
do that and always set fixed size independent to the record number */
if( ulRecNo < 10000000 )
{
hb_itemPutNLLen( pRecNo, ulRecNo, 7 );
}
else
{
hb_itemPutNLLen( pRecNo, ulRecNo, 10 );
}
#else
hb_itemPutNInt( pRecNo, ulRecNo );
#endif
return errCode;
}
| delim1.c | 472 |
| STATIC ERRCODE | hb_delimAppend( DELIMAREAP pArea, BOOL fUnLockAll )
static ERRCODE hb_delimAppend( DELIMAREAP pArea, BOOL fUnLockAll )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimAppend(%p,%d)", pArea, (int) fUnLockAll));
HB_SYMBOL_UNUSED( fUnLockAll );
if( SELF_GOCOLD( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
if( SELF_GOHOT( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
pArea->ulRecordOffset = pArea->ulFileSize;
pArea->ulRecNo = ++pArea->ulRecCount;
pArea->fEof = FALSE;
pArea->fPositioned = TRUE;
hb_delimClearRecordBuffer( pArea );
return SUCCESS;
}
| delim1.c | 501 |
| STATIC ERRCODE | hb_delimDeleteRec( DELIMAREAP pArea )
static ERRCODE hb_delimDeleteRec( DELIMAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimDeleteRec(%p)", pArea));
if( pArea->fRecordChanged )
{
pArea->ulRecCount--;
pArea->fEof = TRUE;
pArea->fPositioned = pArea->fRecordChanged = FALSE;
hb_delimClearRecordBuffer( pArea );
}
return SUCCESS;
}
| delim1.c | 525 |
| STATIC ERRCODE | hb_delimGetValue( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
static ERRCODE hb_delimGetValue( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
LPFIELD pField;
HB_TRACE(HB_TR_DEBUG, ("hb_delimGetValue(%p, %hu, %p)", pArea, uiIndex, pItem));
--uiIndex;
pField = pArea->lpFields + uiIndex;
switch( pField->uiType )
{
case HB_FT_STRING:
#ifndef HB_CDP_SUPPORT_OFF
if( pArea->cdPage != hb_vmCDP() )
{
char * pVal = ( char * ) hb_xgrab( pField->uiLen + 1 );
memcpy( pVal, pArea->pRecord + pArea->pFieldOffset[ uiIndex ], pField->uiLen );
pVal[ pField->uiLen ] = '\0';
hb_cdpnTranslate( pVal, pArea->cdPage, hb_vmCDP(), pField->uiLen );
hb_itemPutCLPtr( pItem, pVal, pField->uiLen );
}
else
#endif
{
hb_itemPutCL( pItem, ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
pField->uiLen );
}
break;
case HB_FT_LOGICAL:
switch( pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] )
{
case 'T':
case 't':
case 'Y':
case 'y':
hb_itemPutL( pItem, TRUE );
break;
default:
hb_itemPutL( pItem, FALSE );
break;
}
break;
case HB_FT_DATE:
hb_itemPutDS( pItem, ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ] );
break;
case HB_FT_LONG:
{
HB_LONG lVal;
double dVal;
BOOL fDbl;
fDbl = hb_strnToNum( (const char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
pField->uiLen, &lVal, &dVal );
if( pField->uiDec )
{
hb_itemPutNDLen( pItem, fDbl ? dVal : ( double ) lVal,
( int ) ( pField->uiLen - pField->uiDec - 1 ),
( int ) pField->uiDec );
}
else if( fDbl )
{
hb_itemPutNDLen( pItem, dVal, ( int ) pField->uiLen, 0 );
}
else
{
hb_itemPutNIntLen( pItem, lVal, ( int ) pField->uiLen );
}
}
break;
case HB_FT_MEMO:
hb_itemPutC( pItem, NULL );
break;
case HB_FT_NONE:
hb_itemClear( pItem );
break;
default:
{
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_errPutSubCode( pError, EDBF_DATATYPE );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
}
return SUCCESS;
}
| delim1.c | 543 |
| STATIC ERRCODE | hb_delimPutValue( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
static ERRCODE hb_delimPutValue( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
char szBuffer[ 256 ];
ERRCODE uiError;
LPFIELD pField;
USHORT uiSize;
HB_TRACE(HB_TR_DEBUG, ("hb_delimPutValue(%p,%hu,%p)", pArea, uiIndex, pItem));
if( !pArea->fPositioned )
return SUCCESS;
if( !pArea->fRecordChanged )
return FAILURE;
uiError = SUCCESS;
--uiIndex;
pField = pArea->lpFields + uiIndex;
if( pField->uiType != HB_FT_MEMO && pField->uiType != HB_FT_NONE )
{
if( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) )
{
if( pField->uiType == HB_FT_STRING )
{
uiSize = ( USHORT ) hb_itemGetCLen( pItem );
if( uiSize > pField->uiLen )
uiSize = pField->uiLen;
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
hb_itemGetCPtr( pItem ), uiSize );
#ifndef HB_CDP_SUPPORT_OFF
hb_cdpnTranslate( (char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_vmCDP(), pArea->cdPage, uiSize );
#endif
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + uiSize,
' ', pField->uiLen - uiSize );
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_DATE( pItem ) )
{
if( pField->uiType == HB_FT_DATE )
{
hb_itemGetDS( pItem, szBuffer );
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, 8 );
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_NUMBER( pItem ) )
{
if( pField->uiType == HB_FT_LONG )
{
if( hb_itemStrBuf( szBuffer, pItem, pField->uiLen, pField->uiDec ) )
{
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
szBuffer, pField->uiLen );
}
else
{
uiError = EDBF_DATAWIDTH;
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
'*', pField->uiLen );
}
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_LOGICAL( pItem ) )
{
if( pField->uiType == HB_FT_LOGICAL )
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] = hb_itemGetL( pItem ) ? 'T' : 'F';
else
uiError = EDBF_DATATYPE;
}
else
uiError = EDBF_DATATYPE;
}
if( uiError != SUCCESS )
{
PHB_ITEM pError= hb_errNew();
USHORT uiGenCode = uiError == EDBF_DATAWIDTH ? EG_DATAWIDTH : EDBF_DATATYPE;
hb_errPutGenCode( pError, uiGenCode );
hb_errPutDescription( pError, hb_langDGetErrorDesc( uiGenCode ) );
hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) );
hb_errPutSubCode( pError, uiError );
hb_errPutFlags( pError, EF_CANDEFAULT );
uiError = SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return uiError == E_DEFAULT ? SUCCESS : FAILURE;
}
return SUCCESS;
}
| delim1.c | 645 |
| STATIC ERRCODE | hb_delimPutRec( DELIMAREAP pArea, BYTE * pBuffer )
static ERRCODE hb_delimPutRec( DELIMAREAP pArea, BYTE * pBuffer )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimPutRec(%p,%p)", pArea, pBuffer));
if( !pArea->fPositioned )
return SUCCESS;
if( !pArea->fRecordChanged )
return FAILURE;
/* Copy data to buffer */
memcpy( pArea->pRecord, pBuffer + 1, pArea->uiRecordLen );
return SUCCESS;
}
| delim1.c | 744 |
| STATIC ERRCODE | hb_delimGetRec( DELIMAREAP pArea, BYTE ** pBufferPtr )
static ERRCODE hb_delimGetRec( DELIMAREAP pArea, BYTE ** pBufferPtr )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimGetRec(%p,%p)", pArea, pBufferPtr));
*pBufferPtr = pArea->pRecord - 1;
return SUCCESS;
}
| delim1.c | 763 |
| STATIC ERRCODE | hb_delimTrans( DELIMAREAP pArea, LPDBTRANSINFO pTransInfo )
static ERRCODE hb_delimTrans( DELIMAREAP pArea, LPDBTRANSINFO pTransInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimTrans(%p, %p)", pArea, pTransInfo));
if( pTransInfo->uiFlags & DBTF_MATCH )
{
if( !pArea->fTransRec || pArea->cdPage != pTransInfo->lpaDest->cdPage )
pTransInfo->uiFlags &= ~DBTF_PUTREC;
else if( pArea->rddID == pTransInfo->lpaDest->rddID )
pTransInfo->uiFlags |= DBTF_PUTREC;
else
{
PHB_ITEM pPutRec = hb_itemPutL( NULL, FALSE );
if( SELF_INFO( ( AREAP ) pTransInfo->lpaDest, DBI_CANPUTREC, pPutRec ) != SUCCESS )
{
hb_itemRelease( pPutRec );
return FAILURE;
}
if( hb_itemGetL( pPutRec ) )
pTransInfo->uiFlags |= DBTF_PUTREC;
else
pTransInfo->uiFlags &= ~DBTF_PUTREC;
hb_itemRelease( pPutRec );
}
}
return SUPER_TRANS( ( AREAP ) pArea, pTransInfo );
}
| delim1.c | 775 |
| STATIC ERRCODE | hb_delimGoCold( DELIMAREAP pArea )
static ERRCODE hb_delimGoCold( DELIMAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimGoCold(%p)", pArea));
if( pArea->fRecordChanged )
{
ULONG ulSize = hb_delimEncodeBuffer( pArea );
if( hb_fileWriteAt( pArea->pFile, pArea->pBuffer, ulSize,
pArea->ulRecordOffset ) != ulSize )
{
PHB_ITEM pError = hb_errNew();
hb_errPutGenCode( pError, EG_WRITE );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_WRITE ) );
hb_errPutSubCode( pError, EDBF_WRITE );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutFileName( pError, pArea->szFileName );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
pArea->ulFileSize += ulSize;
pArea->ulNextOffset = pArea->ulFileSize;
pArea->fRecordChanged = FALSE;
pArea->fFlush = TRUE;
}
return SUCCESS;
}
| delim1.c | 806 |
| STATIC ERRCODE | hb_delimGoHot( DELIMAREAP pArea )
static ERRCODE hb_delimGoHot( DELIMAREAP pArea )
{
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_delimGoHot(%p)", pArea));
if( pArea->fReadonly )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_READONLY );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_READONLY ) );
hb_errPutSubCode( pError, EDBF_READONLY );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
pArea->fRecordChanged = TRUE;
return SUCCESS;
}
| delim1.c | 839 |
| STATIC ERRCODE | hb_delimFlush( DELIMAREAP pArea )
static ERRCODE hb_delimFlush( DELIMAREAP pArea )
{
ERRCODE uiError;
HB_TRACE(HB_TR_DEBUG, ("hb_delimFlush(%p)", pArea));
uiError = SELF_GOCOLD( ( AREAP ) pArea );
if( pArea->fFlush )
{
hb_fileWriteAt( pArea->pFile, ( BYTE * ) "\032", 1, pArea->ulFileSize );
if( hb_setGetHardCommit() )
{
hb_fileCommit( pArea->pFile );
pArea->fFlush = FALSE;
}
}
return uiError;
}
| delim1.c | 862 |
| STATIC ERRCODE | hb_delimInfo( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
static ERRCODE hb_delimInfo( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimInfo(%p,%hu,%p)", pArea, uiIndex, pItem));
switch( uiIndex )
{
case DBI_CANPUTREC:
hb_itemPutL( pItem, pArea->fTransRec );
break;
case DBI_GETRECSIZE:
hb_itemPutNL( pItem, pArea->uiRecordLen );
break;
case DBI_GETDELIMITER:
{
char szDelim[ 2 ];
szDelim[ 0 ] = pArea->cDelim;
szDelim[ 1 ] = '\0';
hb_itemPutC( pItem, szDelim );
break;
}
case DBI_SETDELIMITER:
if( hb_itemType( pItem ) & HB_IT_STRING )
{
char * szDelim = hb_itemGetCPtr( pItem );
if( hb_stricmp( szDelim, "BLANK" ) == 0 )
{
pArea->cDelim = '\0';
pArea->cSeparator = ' ';
}
#ifndef HB_C52_STRICT
else if( hb_stricmp( szDelim, "PIPE" ) == 0 )
{
pArea->cDelim = '\0';
pArea->cSeparator = '|';
}
else if( hb_stricmp( szDelim, "TAB" ) == 0 )
{
pArea->cDelim = '\0';
pArea->cSeparator = '\t';
}
else
#else
else if( *szDelim )
#endif
{
pArea->cDelim = *szDelim;
}
}
/*
* a small trick which allow to set character field delimiter and
* field separator in COPY TO ... and APPEND FROM ... commands as
* array. F.e.:
* COPY TO test DELIMITED WITH ({"","|"})
*/
#ifndef HB_C52_STRICT
else if( hb_itemType( pItem ) & HB_IT_ARRAY )
{
char cSeparator;
if( hb_arrayGetType( pItem, 1 ) & HB_IT_STRING )
pArea->cDelim = *hb_arrayGetCPtr( pItem, 1 );
cSeparator = *hb_arrayGetCPtr( pItem, 2 );
if( cSeparator )
pArea->cSeparator = cSeparator;
}
#endif
break;
case DBI_SEPARATOR:
{
char szSeparator[ 2 ];
char * szNew = hb_itemGetCPtr( pItem );
szSeparator[ 0 ] = pArea->cSeparator;
szSeparator[ 1 ] = '\0';
if( *szNew )
pArea->cSeparator = *szNew;
hb_itemPutC( pItem, szSeparator );
break;
}
case DBI_FULLPATH:
hb_itemPutC( pItem, pArea->szFileName);
break;
case DBI_FILEHANDLE:
hb_itemPutNInt( pItem, ( HB_NHANDLE ) hb_fileHandle( pArea->pFile ) );
break;
case DBI_SHARED:
hb_itemPutL( pItem, pArea->fShared );
break;
case DBI_ISREADONLY:
hb_itemPutL( pItem, pArea->fReadonly );
break;
case DBI_POSITIONED:
hb_itemPutL( pItem, pArea->fPositioned );
break;
case DBI_DB_VERSION:
case DBI_RDD_VERSION:
{
char szBuf[ 64 ];
int iSub = hb_itemGetNI( pItem );
if( iSub == 1 )
snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s)", 0, 1, "DELIM" );
else if( iSub == 2 )
snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s:%d)", 0, 1, "DELIM", pArea->rddID );
else
snprintf( szBuf, sizeof( szBuf ), "%d.%d", 0, 1 );
hb_itemPutC( pItem, szBuf );
break;
}
default:
return SUPER_INFO( ( AREAP ) pArea, uiIndex, pItem );
}
return SUCCESS;
}
| delim1.c | 886 |
| STATIC ERRCODE | hb_delimAddField( DELIMAREAP pArea, LPDBFIELDINFO pFieldInfo )
static ERRCODE hb_delimAddField( DELIMAREAP pArea, LPDBFIELDINFO pFieldInfo )
{
USHORT uiDelim = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_delimAddField(%p, %p)", pArea, pFieldInfo));
switch( pFieldInfo->uiType )
{
case HB_FT_STRING:
uiDelim = 2;
break;
case HB_FT_MEMO:
case HB_FT_IMAGE:
case HB_FT_BLOB:
case HB_FT_OLE:
pFieldInfo->uiType = HB_FT_MEMO;
pFieldInfo->uiLen = 0;
pArea->fTransRec = FALSE;
break;
case HB_FT_ANY:
if( pFieldInfo->uiLen == 3 )
{
pFieldInfo->uiType = HB_FT_DATE;
pFieldInfo->uiLen = 8;
}
else if( pFieldInfo->uiLen < 6 )
{
pFieldInfo->uiType = HB_FT_LONG;
pFieldInfo->uiLen = s_uiNumLength[ pFieldInfo->uiLen ];
}
else
{
pFieldInfo->uiType = HB_FT_MEMO;
pFieldInfo->uiLen = 0;
}
pArea->fTransRec = FALSE;
break;
case HB_FT_DATE:
if( pFieldInfo->uiLen != 8 )
{
pFieldInfo->uiLen = 8;
pArea->fTransRec = FALSE;
}
break;
case HB_FT_FLOAT:
pFieldInfo->uiType = HB_FT_LONG;
break;
case HB_FT_INTEGER:
case HB_FT_CURRENCY:
case HB_FT_ROWVER:
case HB_FT_AUTOINC:
pFieldInfo->uiType = HB_FT_LONG;
pFieldInfo->uiLen = s_uiNumLength[ pFieldInfo->uiLen ];
if( pFieldInfo->uiDec )
pFieldInfo->uiLen++;
pArea->fTransRec = FALSE;
break;
case HB_FT_DOUBLE:
case HB_FT_CURDOUBLE:
pFieldInfo->uiType = HB_FT_LONG;
pFieldInfo->uiLen = 20;
pArea->fTransRec = FALSE;
break;
case HB_FT_VARLENGTH:
pFieldInfo->uiType = HB_FT_STRING;
pArea->fTransRec = FALSE;
uiDelim = 2;
break;
case HB_FT_LOGICAL:
if( pFieldInfo->uiLen != 1 )
{
pFieldInfo->uiLen = 1;
pArea->fTransRec = FALSE;
}
break;
case HB_FT_LONG:
break;
case HB_FT_DAYTIME:
case HB_FT_MODTIME:
pFieldInfo->uiType = HB_FT_STRING;
pFieldInfo->uiLen = 23;
pArea->fTransRec = FALSE;
break;
default:
pFieldInfo->uiType = HB_FT_NONE;
pFieldInfo->uiLen = 0;
pArea->fTransRec = FALSE;
break;
}
/* Update field offset */
pArea->pFieldOffset[ pArea->uiFieldCount ] = pArea->uiRecordLen;
pArea->uiRecordLen += pFieldInfo->uiLen;
pArea->ulBufferSize += pFieldInfo->uiLen + uiDelim + 1;
return SUPER_ADDFIELD( ( AREAP ) pArea, pFieldInfo );
}
| delim1.c | 1015 |
| STATIC ERRCODE | hb_delimSetFieldExtent( DELIMAREAP pArea, USHORT uiFieldExtent )
static ERRCODE hb_delimSetFieldExtent( DELIMAREAP pArea, USHORT uiFieldExtent )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimSetFieldExtent(%p,%hu)", pArea, uiFieldExtent));
if( SUPER_SETFIELDEXTENT( ( AREAP ) pArea, uiFieldExtent ) == FAILURE )
return FAILURE;
/* Alloc field offsets array */
if( uiFieldExtent )
{
pArea->pFieldOffset = ( USHORT * ) hb_xgrab( uiFieldExtent * sizeof( USHORT ) );
memset( pArea->pFieldOffset, 0, uiFieldExtent * sizeof( USHORT ) );
}
return SUCCESS;
}
| delim1.c | 1127 |
| STATIC ERRCODE | hb_delimNewArea( DELIMAREAP pArea )
static ERRCODE hb_delimNewArea( DELIMAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimNewArea(%p)", pArea));
if( SUPER_NEW( ( AREAP ) pArea ) == FAILURE )
return FAILURE;
pArea->pFile = NULL;
pArea->fTransRec = TRUE;
pArea->uiRecordLen = 0;
pArea->ulBufferSize = 0;
/* set character field delimiter */
pArea->cDelim = '"';
/* set field separator */
pArea->cSeparator = ',';
return SUCCESS;
}
| delim1.c | 1147 |
| STATIC ERRCODE | hb_delimStructSize( DELIMAREAP pArea, USHORT * uiSize )
static ERRCODE hb_delimStructSize( DELIMAREAP pArea, USHORT * uiSize )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimStrucSize(%p,%p)", pArea, uiSize));
HB_SYMBOL_UNUSED( pArea );
* uiSize = sizeof( DELIMAREA );
return SUCCESS;
}
| delim1.c | 1171 |
| STATIC ERRCODE | hb_delimClose( DELIMAREAP pArea )
static ERRCODE hb_delimClose( DELIMAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimClose(%p)", pArea));
SUPER_CLOSE( ( AREAP ) pArea );
/* Update record and unlock records */
if( pArea->pFile )
{
SELF_FLUSH( ( AREAP ) pArea );
hb_fileClose( pArea->pFile );
pArea->pFile = NULL;
}
if( pArea->pFieldOffset )
{
hb_xfree( pArea->pFieldOffset );
pArea->pFieldOffset = NULL;
}
if( pArea->pRecord )
{
hb_xfree( pArea->pRecord - 1 );
pArea->pRecord = NULL;
}
if( pArea->pBuffer )
{
hb_xfree( pArea->pBuffer );
pArea->pBuffer = NULL;
}
if( pArea->szEol )
{
hb_xfree( pArea->szEol );
pArea->szEol = NULL;
}
if( pArea->szFileName )
{
hb_xfree( pArea->szFileName );
pArea->szFileName = NULL;
}
return SUCCESS;
}
| delim1.c | 1183 |
| STATIC ERRCODE | hb_delimCreate( DELIMAREAP pArea, LPDBOPENINFO pCreateInfo )
static ERRCODE hb_delimCreate( DELIMAREAP pArea, LPDBOPENINFO pCreateInfo )
{
PHB_ITEM pError = NULL;
PHB_FNAME pFileName;
ERRCODE errCode;
BOOL fRetry;
BYTE szFileName[ _POSIX_PATH_MAX + 1 ];
HB_TRACE(HB_TR_DEBUG, ("hb_delimCreate(%p,%p)", pArea, pCreateInfo));
pArea->fShared = FALSE; /* pCreateInfo->fShared; */
pArea->fReadonly = FALSE; /* pCreateInfo->fReadonly */
#ifndef HB_CDP_SUPPORT_OFF
if( pCreateInfo->cdpId )
{
pArea->cdPage = hb_cdpFind( (char *) pCreateInfo->cdpId );
if( !pArea->cdPage )
pArea->cdPage = hb_vmCDP();
}
else
pArea->cdPage = hb_vmCDP();
#endif
pFileName = hb_fsFNameSplit( ( char * ) pCreateInfo->abName );
if( hb_setGetDefExtension() && ! pFileName->szExtension )
{
PHB_ITEM pItem = hb_itemPutC( NULL, NULL );
SELF_INFO( ( AREAP ) pArea, DBI_TABLEEXT, pItem );
pFileName->szExtension = hb_itemGetCPtr( pItem );
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
hb_itemRelease( pItem );
}
else
{
hb_strncpy( ( char * ) szFileName, ( char * ) pCreateInfo->abName, sizeof( szFileName ) - 1 );
}
hb_xfree( pFileName );
/* Try create */
do
{
pArea->pFile = hb_fileExtOpen( szFileName, NULL,
FO_READWRITE | FO_EXCLUSIVE | FXO_TRUNCATE |
FXO_DEFAULTS | FXO_SHARELOCK | FXO_COPYNAME,
NULL, pError );
if( !pArea->pFile )
{
if( !pError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_CREATE );
hb_errPutSubCode( pError, EDBF_CREATE_DBF );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CREATE ) );
hb_errPutFileName( pError, ( char * ) szFileName );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
}
fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
}
else
fRetry = FALSE;
}
while( fRetry );
if( pError )
hb_itemRelease( pError );
if( !pArea->pFile )
return FAILURE;
errCode = SUPER_CREATE( ( AREAP ) pArea, pCreateInfo );
if( errCode != SUCCESS )
{
SELF_CLOSE( ( AREAP ) pArea );
return errCode;
}
hb_delimInitArea( pArea, ( char * ) szFileName );
/* Position cursor at the first record */
return SELF_GOTOP( ( AREAP ) pArea );
}
| delim1.c | 1229 |
| STATIC ERRCODE | hb_delimOpen( DELIMAREAP pArea, LPDBOPENINFO pOpenInfo )
static ERRCODE hb_delimOpen( DELIMAREAP pArea, LPDBOPENINFO pOpenInfo )
{
PHB_ITEM pError = NULL;
PHB_FNAME pFileName;
ERRCODE errCode;
USHORT uiFlags;
BOOL fRetry;
BYTE szFileName[ _POSIX_PATH_MAX + 1 ];
char szAlias[ HB_RDD_MAX_ALIAS_LEN + 1 ];
HB_TRACE(HB_TR_DEBUG, ("hb_delimOpen(%p,%p)", pArea, pOpenInfo));
pArea->fShared = TRUE; /* pOpenInfo->fShared; */
pArea->fReadonly = TRUE; /* pOpenInfo->fReadonly; */
#ifndef HB_CDP_SUPPORT_OFF
if( pOpenInfo->cdpId )
{
pArea->cdPage = hb_cdpFind( (char *) pOpenInfo->cdpId );
if( !pArea->cdPage )
pArea->cdPage = hb_vmCDP();
}
else
pArea->cdPage = hb_vmCDP();
#endif
uiFlags = ( pArea->fReadonly ? FO_READ : FO_READWRITE ) |
( pArea->fShared ? FO_DENYNONE : FO_EXCLUSIVE );
pFileName = hb_fsFNameSplit( ( char * ) pOpenInfo->abName );
/* Add default file name extension if necessary */
if( hb_setGetDefExtension() && ! pFileName->szExtension )
{
PHB_ITEM pFileExt = hb_itemPutC( NULL, NULL );
SELF_INFO( ( AREAP ) pArea, DBI_TABLEEXT, pFileExt );
pFileName->szExtension = hb_itemGetCPtr( pFileExt );
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
hb_itemRelease( pFileExt );
}
else
{
hb_strncpy( ( char * ) szFileName, ( char * ) pOpenInfo->abName, sizeof( szFileName ) - 1 );
}
/* Create default alias if necessary */
if( !pOpenInfo->atomAlias && pFileName->szName )
{
hb_strncpyUpperTrim( szAlias, pFileName->szName, sizeof( szAlias ) - 1 );
pOpenInfo->atomAlias = ( BYTE * ) szAlias;
}
hb_xfree( pFileName );
/* Try open */
do
{
pArea->pFile = hb_fileExtOpen( szFileName, NULL, uiFlags |
FXO_DEFAULTS | FXO_SHARELOCK | FXO_COPYNAME,
NULL, pError );
if( !pArea->pFile )
{
if( !pError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_OPEN );
hb_errPutSubCode( pError, EDBF_OPEN_DBF );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_OPEN ) );
hb_errPutFileName( pError, ( char * ) szFileName );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
}
fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
}
else
fRetry = FALSE;
}
while( fRetry );
if( pError )
hb_itemRelease( pError );
if( !pArea->pFile )
return FAILURE;
errCode = SUPER_OPEN( ( AREAP ) pArea, pOpenInfo );
if( errCode != SUCCESS )
{
SELF_CLOSE( ( AREAP ) pArea );
return FAILURE;
}
hb_delimInitArea( pArea, ( char * ) szFileName );
/* Position cursor at the first record */
return SELF_GOTOP( ( AREAP ) pArea );
}
| delim1.c | 1315 |
| STATIC ERRCODE | hb_delimRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem )
static ERRCODE hb_delimRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimRddInfo(%p,%hu,%lu,%p)", pRDD, uiIndex, ulConnect, pItem));
switch( uiIndex )
{
case RDDI_CANPUTREC:
case RDDI_LOCAL:
hb_itemPutL( pItem, TRUE );
break;
case RDDI_TABLEEXT:
hb_itemPutC( pItem, DELIM_TABLEEXT );
break;
default:
return SUPER_RDDINFO( pRDD, uiIndex, ulConnect, pItem );
}
return SUCCESS;
}
static const RDDFUNCS delimTable = { NULL /* hb_delimBof */,
NULL /* hb_delimEof */,
NULL /* hb_delimFound */,
NULL /* hb_delimGoBottom */,
NULL /* hb_delimGoTo */,
NULL /* hb_delimGoToId */,
( DBENTRYP_V ) hb_delimGoTop,
NULL /* hb_delimSeek */,
NULL /* hb_delimSkip */,
NULL /* hb_delimSkipFilter */,
( DBENTRYP_L ) hb_delimSkipRaw,
( DBENTRYP_VF ) hb_delimAddField,
( DBENTRYP_B ) hb_delimAppend,
NULL /* hb_delimCreateFields */,
( DBENTRYP_V ) hb_delimDeleteRec,
( DBENTRYP_BP ) hb_delimDeleted,
NULL /* hb_delimFieldCount */,
NULL /* hb_delimFieldDisplay */,
NULL /* hb_delimFieldInfo */,
NULL /* hb_delimFieldName */,
( DBENTRYP_V ) hb_delimFlush,
( DBENTRYP_PP ) hb_delimGetRec,
( DBENTRYP_SI ) hb_delimGetValue,
NULL /* hb_delimGetVarLen */,
( DBENTRYP_V ) hb_delimGoCold,
( DBENTRYP_V ) hb_delimGoHot,
( DBENTRYP_P ) hb_delimPutRec,
( DBENTRYP_SI ) hb_delimPutValue,
NULL /* hb_delimRecall */,
( DBENTRYP_ULP ) hb_delimRecCount,
NULL /* hb_delimRecInfo */,
( DBENTRYP_ULP ) hb_delimRecNo,
( DBENTRYP_I ) hb_delimRecId,
( DBENTRYP_S ) hb_delimSetFieldExtent,
NULL /* hb_delimAlias */,
( DBENTRYP_V ) hb_delimClose,
( DBENTRYP_VP ) hb_delimCreate,
( DBENTRYP_SI ) hb_delimInfo,
( DBENTRYP_V ) hb_delimNewArea,
( DBENTRYP_VP ) hb_delimOpen,
NULL /* hb_delimRelease */,
( DBENTRYP_SP ) hb_delimStructSize,
NULL /* hb_delimSysName */,
NULL /* hb_delimEval */,
NULL /* hb_delimPack */,
NULL /* hb_delimPackRec */,
NULL /* hb_delimSort */,
( DBENTRYP_VT ) hb_delimTrans,
NULL /* hb_delimTransRec */,
NULL /* hb_delimZap */,
NULL /* hb_delimChildEnd */,
NULL /* hb_delimChildStart */,
NULL /* hb_delimChildSync */,
NULL /* hb_delimSyncChildren */,
NULL /* hb_delimClearRel */,
NULL /* hb_delimForceRel */,
NULL /* hb_delimRelArea */,
NULL /* hb_delimRelEval */,
NULL /* hb_delimRelText */,
NULL /* hb_delimSetRel */,
NULL /* hb_delimOrderListAdd */,
NULL /* hb_delimOrderListClear */,
NULL /* hb_delimOrderListDelete */,
NULL /* hb_delimOrderListFocus */,
NULL /* hb_delimOrderListRebuild */,
NULL /* hb_delimOrderCondition */,
NULL /* hb_delimOrderCreate */,
NULL /* hb_delimOrderDestroy */,
NULL /* hb_delimOrderInfo */,
NULL /* hb_delimClearFilter */,
NULL /* hb_delimClearLocate */,
NULL /* hb_delimClearScope */,
NULL /* hb_delimCountScope */,
NULL /* hb_delimFilterText */,
NULL /* hb_delimScopeInfo */,
NULL /* hb_delimSetFilter */,
NULL /* hb_delimSetLocate */,
NULL /* hb_delimSetScope */,
NULL /* hb_delimSkipScope */,
NULL /* hb_delimLocate */,
NULL /* hb_delimCompile */,
NULL /* hb_delimError */,
NULL /* hb_delimEvalBlock */,
NULL /* hb_delimRawLock */,
NULL /* hb_delimLock */,
NULL /* hb_delimUnLock */,
NULL /* hb_delimCloseMemFile */,
NULL /* hb_delimCreateMemFile */,
NULL /* hb_delimGetValueFile */,
NULL /* hb_delimOpenMemFile */,
NULL /* hb_delimPutValueFile */,
NULL /* hb_delimReadDBHeader */,
NULL /* hb_delimWriteDBHeader */,
NULL /* hb_delimInit */,
NULL /* hb_delimExit */,
NULL /* hb_delimDrop */,
NULL /* hb_delimExists */,
( DBENTRYP_RSLV ) hb_delimRddInfo,
NULL /* hb_delimWhoCares */
};
/*
* -- DELIM METHODS --
*/
HB_FUNC( DELIM ) { ; }
| delim1.c | 1413 |
| } | HB_FUNC( DELIM_GETFUNCTABLE )
HB_FUNC( DELIM_GETFUNCTABLE )
{
RDDFUNCS * pTable;
USHORT * uiCount;
uiCount = ( USHORT * ) hb_parptr( 1 );
pTable = ( RDDFUNCS * ) hb_parptr( 2 );
HB_TRACE(HB_TR_DEBUG, ("DELIM_GETFUNCTABLE(%p, %p)", uiCount, pTable));
if( pTable )
{
if( uiCount )
* uiCount = RDDFUNCSCOUNT;
hb_retni( hb_rddInherit( pTable, &delimTable, &delimSuper, NULL ) );
}
else
hb_retni( FAILURE );
}
| delim1.c | 1549 |
| STATIC VOID | hb_delimRddInit( void * cargo )
static void hb_delimRddInit( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
if( hb_rddRegister( "DELIM", RDT_TRANSFER ) > 1 )
{
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
}
}
| delim1.c | 1577 |
| HB_INIT_SYMBOLS_BEGIN( | delim1__InitSymbols )
HB_INIT_SYMBOLS_BEGIN( delim1__InitSymbols )
{ "DELIM", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( DELIM )}, NULL },
{ "DELIM_GETFUNCTABLE", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( DELIM_GETFUNCTABLE )}, NULL }
HB_INIT_SYMBOLS_END( delim1__InitSymbols )
HB_CALL_ON_STARTUP_BEGIN( _hb_delim_rdd_init_ )
hb_vmAtInit( hb_delimRddInit, NULL );
HB_CALL_ON_STARTUP_END( _hb_delim_rdd_init_ )
#if defined( HB_PRAGMA_STARTUP )
#pragma startup delim1__InitSymbols
#pragma startup _hb_delim_rdd_init_
#elif defined( HB_MSC_STARTUP )
#if defined( HB_OS_WIN_64 )
#pragma section( HB_MSC_START_SEGMENT, long, read )
#endif
#pragma data_seg( HB_MSC_START_SEGMENT )
static HB_$INITSYM hb_vm_auto_delim1__InitSymbols = delim1__InitSymbols;
static HB_$INITSYM hb_vm_auto_delim_rdd_init = _hb_delim_rdd_init_;
| delim1.c | 1587 |
| fieldhb.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | FIELDLEN(void)
HB_FUNC( FIELDLEN )
{
HB_FUNC_EXEC( HB_FIELDLEN );
}
HB_FUNC_EXTERN( HB_FIELDDEC );
| fieldhb.c | 62 |
| HB_FUNC | FIELDDEC(void)
HB_FUNC( FIELDDEC )
{
HB_FUNC_EXEC( HB_FIELDDEC );
}
HB_FUNC_EXTERN( HB_FIELDTYPE );
| fieldhb.c | 69 |
| HB_FUNC | FIELDTYPE(void)
HB_FUNC( FIELDTYPE )
{
HB_FUNC_EXEC( HB_FIELDTYPE );
}
| fieldhb.c | 76 |
| hbdbsort.c |
| Type | Function | Source | Line |
|---|
| BOOL | hb_dbQSortInit( LPDBQUICKSORT pQuickSort, LPDBSORTINFO pSortInfo, USHORT uiRecordLen )
BOOL hb_dbQSortInit( LPDBQUICKSORT pQuickSort, LPDBSORTINFO pSortInfo, USHORT uiRecordLen )
{
/* Create temp file */
pQuickSort->hFile = hb_fsCreateTemp( NULL, NULL, FC_NORMAL, pQuickSort->szTempName );
if( pQuickSort->hFile == FS_ERROR )
return FALSE;
/* Alloc buffers */
pQuickSort->uiMaxRecords = USHRT_MAX / uiRecordLen;
pQuickSort->pBuffer = ( BYTE * ) hb_xgrab( pQuickSort->uiMaxRecords * uiRecordLen );
pQuickSort->pSwapBufferA = ( BYTE * ) hb_xgrab( uiRecordLen );
pQuickSort->pSwapBufferB = ( BYTE * ) hb_xgrab( uiRecordLen );
pQuickSort->pCmpBufferA = ( BYTE * ) hb_xgrab( uiRecordLen );
pQuickSort->pCmpBufferB = ( BYTE * ) hb_xgrab( uiRecordLen );
/* Fill structure */
pQuickSort->uiRecordLen = uiRecordLen;
pQuickSort->pSortInfo = pSortInfo;
return TRUE;
}
| hbdbsort.c | 55 |
| VOID | hb_dbQSortExit( LPDBQUICKSORT pQuickSort )
void hb_dbQSortExit( LPDBQUICKSORT pQuickSort )
{
/* Close and delete temp file */
hb_fsClose( pQuickSort->hFile );
hb_fsDelete( pQuickSort->szTempName );
/* Free buffers */
hb_xfree( pQuickSort->pBuffer );
hb_xfree( pQuickSort->pSwapBufferA );
hb_xfree( pQuickSort->pSwapBufferB );
hb_xfree( pQuickSort->pCmpBufferA );
hb_xfree( pQuickSort->pCmpBufferB );
}
| hbdbsort.c | 76 |
| BOOL | hb_dbQSortAdvance( LPDBQUICKSORT pQuickSort, USHORT uiCount )
BOOL hb_dbQSortAdvance( LPDBQUICKSORT pQuickSort, USHORT uiCount )
{
USHORT uiSize;
/* Write chunk */
uiSize = uiCount * pQuickSort->uiRecordLen;
return ( hb_fsWrite( pQuickSort->hFile, pQuickSort->pBuffer, uiSize ) == uiSize );
}
| hbdbsort.c | 90 |
| STATIC BOOL | hb_dbQSortIsLess( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG ulRecNo2 )
static BOOL hb_dbQSortIsLess( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG ulRecNo2 )
{
USHORT uiCount, uiField;
DBFAREAP pArea;
LPFIELD pField;
BOOL bAscending, bIgnoreCase;
int iResult;
pArea = ( DBFAREAP ) pQuickSort->pSortInfo->dbtri.lpaSource;
/* Read records */
hb_fsSeek( pQuickSort->hFile, ( ulRecNo1 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsRead( pQuickSort->hFile, pQuickSort->pSwapBufferA, pQuickSort->uiRecordLen );
hb_fsSeek( pQuickSort->hFile, ( ulRecNo2 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsRead( pQuickSort->hFile, pQuickSort->pSwapBufferB, pQuickSort->uiRecordLen );
/* Compare fields */
for( uiCount = 0; uiCount < pQuickSort->pSortInfo->uiItemCount; uiCount++ )
{
/* Sort flags */
bIgnoreCase = ( ( pQuickSort->pSortInfo->lpdbsItem[ uiCount ].uiFlags & SF_CASE ) == SF_CASE );
bAscending = ( ( pQuickSort->pSortInfo->lpdbsItem[ uiCount ].uiFlags & SF_ASCEND ) == SF_ASCEND );
uiField = pQuickSort->pSortInfo->lpdbsItem[ uiCount ].uiField - 1;
pField = pArea->lpFields + uiField;
if( pField->uiType == HB_IT_MEMO )
continue;
if( pField->uiType == HB_IT_LOGICAL )
{
if( pQuickSort->pSwapBufferA[ pArea->pFieldOffset[ uiField ] ] == 'T' ||
pQuickSort->pSwapBufferA[ pArea->pFieldOffset[ uiField ] ] == 't' ||
pQuickSort->pSwapBufferA[ pArea->pFieldOffset[ uiField ] ] == 'Y' ||
pQuickSort->pSwapBufferA[ pArea->pFieldOffset[ uiField ] ] == 'y' )
* pQuickSort->pCmpBufferA = '1';
else
* pQuickSort->pCmpBufferA = '0';
if( pQuickSort->pSwapBufferB[ pArea->pFieldOffset[ uiField ] ] == 'T' ||
pQuickSort->pSwapBufferB[ pArea->pFieldOffset[ uiField ] ] == 't' ||
pQuickSort->pSwapBufferB[ pArea->pFieldOffset[ uiField ] ] == 'Y' ||
pQuickSort->pSwapBufferB[ pArea->pFieldOffset[ uiField ] ] == 'y' )
* pQuickSort->pCmpBufferB = '1';
else
* pQuickSort->pCmpBufferB = '0';
}
else
{
memcpy( pQuickSort->pCmpBufferA, pQuickSort->pSwapBufferA +
pArea->pFieldOffset[ uiField ], pField->uiLen );
memcpy( pQuickSort->pCmpBufferB, pQuickSort->pSwapBufferB +
pArea->pFieldOffset[ uiField ], pField->uiLen );
}
pQuickSort->pCmpBufferA[ pField->uiLen ] = 0;
pQuickSort->pCmpBufferB[ pField->uiLen ] = 0;
/* Compare buffers */
if( bIgnoreCase )
iResult = hb_stricmp( ( const char * ) pQuickSort->pCmpBufferA,
( const char * ) pQuickSort->pCmpBufferB );
else
iResult = strcmp( ( const char * ) pQuickSort->pCmpBufferA,
( const char * ) pQuickSort->pCmpBufferB );
if( iResult == 0 )
continue;
else if( bAscending )
return ( iResult < 0 );
else
return ( iResult > 0 );
}
return FALSE;
}
| hbdbsort.c | 99 |
| STATIC VOID | hb_dbQSortSwap( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG ulRecNo2 )
static void hb_dbQSortSwap( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG ulRecNo2 )
{
/* Swap records */
hb_fsSeek( pQuickSort->hFile, ( ulRecNo1 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsRead( pQuickSort->hFile, pQuickSort->pSwapBufferA, pQuickSort->uiRecordLen );
hb_fsSeek( pQuickSort->hFile, ( ulRecNo2 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsRead( pQuickSort->hFile, pQuickSort->pSwapBufferB, pQuickSort->uiRecordLen );
hb_fsSeek( pQuickSort->hFile, ( ulRecNo1 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsWrite( pQuickSort->hFile, pQuickSort->pSwapBufferB, pQuickSort->uiRecordLen );
hb_fsSeek( pQuickSort->hFile, ( ulRecNo2 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsWrite( pQuickSort->hFile, pQuickSort->pSwapBufferA, pQuickSort->uiRecordLen );
}
| hbdbsort.c | 171 |
| STATIC VOID | hb_dbQSortDo( LPDBQUICKSORT pQuickSort, ULONG ulFirst, ULONG ulLast )
static void hb_dbQSortDo( LPDBQUICKSORT pQuickSort, ULONG ulFirst, ULONG ulLast )
{
ULONG ulPivot, ulLeft, ulRight;
/* Select pivot */
if( hb_dbQSortIsLess( pQuickSort, ulFirst, ulLast ) )
ulPivot = ulLast;
else
ulPivot = ulFirst;
ulLeft = ulFirst;
ulRight = ulLast;
do
{
/* partition into two segments */
while( ulLeft <= ulLast && hb_dbQSortIsLess( pQuickSort, ulLeft, ulPivot ) )
ulLeft++;
while( ulRight >= ulFirst && hb_dbQSortIsLess( pQuickSort, ulPivot, ulRight ) )
ulRight--;
if( ulLeft <= ulRight )
{
/* Swap records */
if( ulLeft < ulRight )
hb_dbQSortSwap( pQuickSort, ulLeft, ulRight );
ulLeft++;
ulRight--;
}
} while( ulLeft <= ulRight );
/* Sort segment */
if( ulFirst < ulRight )
hb_dbQSortDo( pQuickSort, ulFirst, ulRight );
/* Sort segment */
if( ulLeft < ulLast )
hb_dbQSortDo( pQuickSort, ulLeft, ulLast );
}
| hbdbsort.c | 184 |
| VOID | hb_dbQSortComplete( LPDBQUICKSORT pQuickSort )
void hb_dbQSortComplete( LPDBQUICKSORT pQuickSort )
{
ULONG ulRecCount;
AREAP pArea;
ulRecCount = hb_fsSeek( pQuickSort->hFile, 0, FS_END ) / pQuickSort->uiRecordLen;
if( ulRecCount >= 1 )
{
hb_dbQSortDo( pQuickSort, 1, ulRecCount );
pArea = pQuickSort->pSortInfo->dbtri.lpaDest;
hb_fsSeek( pQuickSort->hFile, 0, FS_SET );
while( ulRecCount-- > 0 )
{
/* Read sorted record */
hb_fsRead( pQuickSort->hFile, pQuickSort->pSwapBufferA, pQuickSort->uiRecordLen );
/* Remove deleted flag */
pQuickSort->pSwapBufferA[ 0 ] = ' ';
#ifndef HB_CDP_SUPPORT_OFF
if( pArea->cdPage != hb_vmCDP() )
{
hb_dbfTranslateRec( (DBFAREAP) pArea, (BYTE *) pQuickSort->pSwapBufferA, hb_vmCDP(), pArea->cdPage );
}
#endif
/* Append a new record and copy data */
if( SELF_APPEND( pArea, TRUE ) == FAILURE ||
SELF_PUTREC( pArea, pQuickSort->pSwapBufferA ) == FAILURE )
break;
}
}
hb_dbQSortExit( pQuickSort );
}
| hbdbsort.c | 224 |
| rddinfo.c |
| Type | Function | Source | Line |
|---|
| HB_FUNC | RDDINFO(void)
HB_FUNC( RDDINFO )
{
HB_FUNC_EXEC( HB_RDDINFO )
}
| rddinfo.c | 62 |
| sdf1.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_sdfInitArea( SDFAREAP pArea, char * szFileName )
static void hb_sdfInitArea( SDFAREAP pArea, char * szFileName )
{
char * szEol;
/* Allocate only after succesfully open file */
pArea->szFileName = hb_strdup( szFileName );
/* set line separator: EOL */
szEol = hb_setGetEOL();
if( !szEol || !szEol[ 0 ] )
szEol = hb_conNewLine();
pArea->szEol = hb_strdup( szEol );
pArea->uiEolLen = strlen( pArea->szEol );
/* Alloc buffer */
pArea->pRecord = ( BYTE * ) hb_xgrab( pArea->uiRecordLen + pArea->uiEolLen + 3 );
/* pseudo deleted flag */
*pArea->pRecord++ = ' ';
pArea->ulFileSize = 0;
pArea->ulRecCount = 0;
}
| sdf1.c | 70 |
| STATIC VOID | hb_sdfClearRecordBuffer( SDFAREAP pArea )
static void hb_sdfClearRecordBuffer( SDFAREAP pArea )
{
memset( pArea->pRecord, ' ', pArea->uiRecordLen );
memcpy( pArea->pRecord + pArea->uiRecordLen,
pArea->szEol, pArea->uiEolLen );
}
| sdf1.c | 93 |
| STATIC ERRCODE | hb_sdfReadRecord( SDFAREAP pArea )
static ERRCODE hb_sdfReadRecord( SDFAREAP pArea )
{
USHORT uiRead, uiToRead, uiEolPos;
HB_TRACE(HB_TR_DEBUG, ("hb_sdfReadRecord(%p)", pArea));
uiToRead = pArea->uiRecordLen + pArea->uiEolLen + 2;
uiRead = hb_fileReadAt( pArea->pFile, pArea->pRecord, uiToRead,
pArea->ulRecordOffset );
if( uiRead > 0 && uiRead < uiToRead && pArea->pRecord[ uiRead - 1 ] == '\032' )
--uiRead;
if( uiRead == 0 )
{
pArea->fEof = TRUE;
pArea->fPositioned = FALSE;
hb_sdfClearRecordBuffer( pArea );
}
else
{
pArea->fEof = FALSE;
pArea->fPositioned = TRUE;
uiEolPos = ( USHORT ) hb_strAt( pArea->szEol, pArea->uiEolLen,
( char * ) pArea->pRecord, uiRead );
if( uiEolPos )
{
--uiEolPos;
if( uiRead == pArea->uiRecordLen + pArea->uiEolLen )
pArea->ulNextOffset = ( HB_FOFFSET ) -1;
else
pArea->ulNextOffset = pArea->ulRecordOffset + uiEolPos + pArea->uiEolLen;
if( uiEolPos < pArea->uiRecordLen )
memset( pArea->pRecord + uiEolPos, ' ', pArea->uiRecordLen - uiEolPos );
}
else
{
if( uiRead < uiToRead )
pArea->ulNextOffset = ( HB_FOFFSET ) -1;
else
pArea->ulNextOffset = 0;
if( uiRead < pArea->uiRecordLen )
memset( pArea->pRecord + uiRead, ' ', pArea->uiRecordLen - uiRead );
}
if( uiEolPos != pArea->uiRecordLen )
memcpy( pArea->pRecord + pArea->uiRecordLen,
pArea->szEol, pArea->uiEolLen );
}
return SUCCESS;
}
| sdf1.c | 100 |
| STATIC ERRCODE | hb_sdfNextRecord( SDFAREAP pArea )
static ERRCODE hb_sdfNextRecord( SDFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfNextRecord(%p)", pArea));
if( !pArea->fPositioned )
pArea->ulNextOffset = ( HB_FOFFSET ) -1;
else
{
if( pArea->ulNextOffset == 0 )
{
USHORT uiRead, uiToRead, uiEolPos, uiRest = 0;
HB_FOFFSET ulOffset = pArea->ulRecordOffset;
uiToRead = pArea->uiRecordLen + pArea->uiEolLen + 2;
do
{
uiRead = hb_fileReadAt( pArea->pFile, pArea->pRecord + uiRest,
uiToRead - uiRest, ulOffset + uiRest ) + uiRest;
if( uiRead > 0 && uiRead < uiToRead &&
pArea->pRecord[ uiRead - 1 ] == '\032' )
--uiRead;
uiEolPos = ( USHORT ) hb_strAt( pArea->szEol, pArea->uiEolLen,
( char * ) pArea->pRecord, uiRead );
if( uiEolPos )
{
--uiEolPos;
if( uiRead == pArea->uiRecordLen + pArea->uiEolLen )
pArea->ulNextOffset = ( HB_FOFFSET ) -1;
else
pArea->ulNextOffset = ulOffset + uiEolPos + pArea->uiEolLen;
}
else if( uiRead < uiToRead )
{
pArea->ulNextOffset = ( HB_FOFFSET ) -1;
}
else
{
if( pArea->uiEolLen > 1 )
{
uiRest = pArea->uiEolLen - 1;
memcpy( pArea->pRecord, pArea->pRecord + uiRead - uiRest, uiRest );
}
ulOffset += uiRead - uiRest;
}
}
while( pArea->ulNextOffset == 0 );
}
pArea->ulRecNo++;
}
if( pArea->ulNextOffset == ( HB_FOFFSET ) -1 )
{
pArea->fEof = TRUE;
pArea->fPositioned = FALSE;
hb_sdfClearRecordBuffer( pArea );
return SUCCESS;
}
pArea->ulRecordOffset = pArea->ulNextOffset;
return hb_sdfReadRecord( pArea );
}
| sdf1.c | 154 |
| STATIC ERRCODE | hb_sdfGoTop( SDFAREAP pArea )
static ERRCODE hb_sdfGoTop( SDFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfGoTop(%p)", pArea));
if( SELF_GOCOLD( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
pArea->fTop = TRUE;
pArea->fBottom = FALSE;
pArea->ulRecordOffset = 0;
pArea->ulRecNo = 1;
if( hb_sdfReadRecord( pArea ) != SUCCESS )
return FAILURE;
return SELF_SKIPFILTER( ( AREAP ) pArea, 1 );
}
| sdf1.c | 222 |
| STATIC ERRCODE | hb_sdfSkipRaw( SDFAREAP pArea, LONG lToSkip )
static ERRCODE hb_sdfSkipRaw( SDFAREAP pArea, LONG lToSkip )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfSkipRaw(%p,%ld)", pArea, lToSkip));
if( SELF_GOCOLD( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
if( lToSkip != 1 )
return FAILURE;
else
return hb_sdfNextRecord( pArea );
}
| sdf1.c | 243 |
| STATIC ERRCODE | hb_sdfDeleted( SDFAREAP pArea, BOOL * pDeleted )
static ERRCODE hb_sdfDeleted( SDFAREAP pArea, BOOL * pDeleted )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfDeleted(%p,%p)", pArea, pDeleted));
HB_SYMBOL_UNUSED( pArea );
* pDeleted = FALSE;
return SUCCESS;
}
| sdf1.c | 259 |
| STATIC ERRCODE | hb_sdfRecCount( SDFAREAP pArea, ULONG * pRecCount )
static ERRCODE hb_sdfRecCount( SDFAREAP pArea, ULONG * pRecCount )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfRecCount(%p,%p)", pArea, pRecCount));
* pRecCount = pArea->ulRecCount;
return SUCCESS;
}
| sdf1.c | 273 |
| STATIC ERRCODE | hb_sdfRecNo( SDFAREAP pArea, ULONG * pulRecNo )
static ERRCODE hb_sdfRecNo( SDFAREAP pArea, ULONG * pulRecNo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfRecNo(%p,%p)", pArea, pulRecNo));
*pulRecNo = pArea->ulRecNo;
return SUCCESS;
}
| sdf1.c | 284 |
| STATIC ERRCODE | hb_sdfRecId( SDFAREAP pArea, PHB_ITEM pRecNo )
static ERRCODE hb_sdfRecId( SDFAREAP pArea, PHB_ITEM pRecNo )
{
ERRCODE errCode;
ULONG ulRecNo;
HB_TRACE(HB_TR_DEBUG, ("hb_sdfRecId(%p,%p)", pArea, pRecNo));
errCode = SELF_RECNO( ( AREAP ) pArea, &ulRecNo );
#ifdef HB_C52_STRICT
/* this is for strict Clipper compatibility but IMHO Clipper should not
do that and always set fixed size independent to the record number */
if( ulRecNo < 10000000 )
{
hb_itemPutNLLen( pRecNo, ulRecNo, 7 );
}
else
{
hb_itemPutNLLen( pRecNo, ulRecNo, 10 );
}
#else
hb_itemPutNInt( pRecNo, ulRecNo );
#endif
return errCode;
}
| sdf1.c | 295 |
| STATIC ERRCODE | hb_sdfAppend( SDFAREAP pArea, BOOL fUnLockAll )
static ERRCODE hb_sdfAppend( SDFAREAP pArea, BOOL fUnLockAll )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfAppend(%p,%d)", pArea, (int) fUnLockAll));
HB_SYMBOL_UNUSED( fUnLockAll );
if( SELF_GOCOLD( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
if( SELF_GOHOT( ( AREAP ) pArea ) != SUCCESS )
return FAILURE;
pArea->ulRecordOffset = pArea->ulFileSize;
pArea->ulRecNo = ++pArea->ulRecCount;
pArea->fEof = FALSE;
pArea->fPositioned = TRUE;
hb_sdfClearRecordBuffer( pArea );
return SUCCESS;
}
| sdf1.c | 324 |
| STATIC ERRCODE | hb_sdfDeleteRec( SDFAREAP pArea )
static ERRCODE hb_sdfDeleteRec( SDFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfDeleteRec(%p)", pArea));
if( pArea->fRecordChanged )
{
pArea->ulRecCount--;
pArea->fEof = TRUE;
pArea->fPositioned = pArea->fRecordChanged = FALSE;
hb_sdfClearRecordBuffer( pArea );
}
return SUCCESS;
}
| sdf1.c | 348 |
| STATIC ERRCODE | hb_sdfGetValue( SDFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
static ERRCODE hb_sdfGetValue( SDFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
LPFIELD pField;
HB_TRACE(HB_TR_DEBUG, ("hb_sdfGetValue(%p, %hu, %p)", pArea, uiIndex, pItem));
--uiIndex;
pField = pArea->lpFields + uiIndex;
switch( pField->uiType )
{
case HB_FT_STRING:
#ifndef HB_CDP_SUPPORT_OFF
if( pArea->cdPage != hb_vmCDP() )
{
char * pVal = ( char * ) hb_xgrab( pField->uiLen + 1 );
memcpy( pVal, pArea->pRecord + pArea->pFieldOffset[ uiIndex ], pField->uiLen );
pVal[ pField->uiLen ] = '\0';
hb_cdpnTranslate( pVal, pArea->cdPage, hb_vmCDP(), pField->uiLen );
hb_itemPutCLPtr( pItem, pVal, pField->uiLen );
}
else
#endif
{
hb_itemPutCL( pItem, ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
pField->uiLen );
}
break;
case HB_FT_LOGICAL:
switch( pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] )
{
case 'T':
case 't':
case 'Y':
case 'y':
hb_itemPutL( pItem, TRUE );
break;
default:
hb_itemPutL( pItem, FALSE );
break;
}
break;
case HB_FT_DATE:
hb_itemPutDS( pItem, ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ] );
break;
case HB_FT_LONG:
{
HB_LONG lVal;
double dVal;
BOOL fDbl;
fDbl = hb_strnToNum( (const char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
pField->uiLen, &lVal, &dVal );
if( pField->uiDec )
{
hb_itemPutNDLen( pItem, fDbl ? dVal : ( double ) lVal,
( int ) ( pField->uiLen - pField->uiDec - 1 ),
( int ) pField->uiDec );
}
else if( fDbl )
{
hb_itemPutNDLen( pItem, dVal, ( int ) pField->uiLen, 0 );
}
else
{
hb_itemPutNIntLen( pItem, lVal, ( int ) pField->uiLen );
}
}
break;
case HB_FT_MEMO:
hb_itemPutC( pItem, NULL );
break;
case HB_FT_NONE:
hb_itemClear( pItem );
break;
default:
{
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_errPutSubCode( pError, EDBF_DATATYPE );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
}
return SUCCESS;
}
| sdf1.c | 366 |
| STATIC ERRCODE | hb_sdfPutValue( SDFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
static ERRCODE hb_sdfPutValue( SDFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
char szBuffer[ 256 ];
ERRCODE uiError;
LPFIELD pField;
USHORT uiSize;
HB_TRACE(HB_TR_DEBUG, ("hb_sdfPutValue(%p,%hu,%p)", pArea, uiIndex, pItem));
if( !pArea->fPositioned )
return SUCCESS;
if( !pArea->fRecordChanged )
return FAILURE;
uiError = SUCCESS;
--uiIndex;
pField = pArea->lpFields + uiIndex;
if( pField->uiType != HB_FT_MEMO && pField->uiType != HB_FT_NONE )
{
if( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) )
{
if( pField->uiType == HB_FT_STRING )
{
uiSize = ( USHORT ) hb_itemGetCLen( pItem );
if( uiSize > pField->uiLen )
uiSize = pField->uiLen;
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
hb_itemGetCPtr( pItem ), uiSize );
#ifndef HB_CDP_SUPPORT_OFF
hb_cdpnTranslate( (char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_vmCDP(), pArea->cdPage, uiSize );
#endif
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + uiSize,
' ', pField->uiLen - uiSize );
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_DATE( pItem ) )
{
if( pField->uiType == HB_FT_DATE )
{
hb_itemGetDS( pItem, szBuffer );
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, 8 );
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_NUMBER( pItem ) )
{
if( pField->uiType == HB_FT_LONG )
{
if( hb_itemStrBuf( szBuffer, pItem, pField->uiLen, pField->uiDec ) )
{
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
szBuffer, pField->uiLen );
}
else
{
uiError = EDBF_DATAWIDTH;
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
'*', pField->uiLen );
}
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_LOGICAL( pItem ) )
{
if( pField->uiType == HB_FT_LOGICAL )
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] = hb_itemGetL( pItem ) ? 'T' : 'F';
else
uiError = EDBF_DATATYPE;
}
else
uiError = EDBF_DATATYPE;
}
if( uiError != SUCCESS )
{
PHB_ITEM pError= hb_errNew();
USHORT uiGenCode = uiError == EDBF_DATAWIDTH ? EG_DATAWIDTH : EDBF_DATATYPE;
hb_errPutGenCode( pError, uiGenCode );
hb_errPutDescription( pError, hb_langDGetErrorDesc( uiGenCode ) );
hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) );
hb_errPutSubCode( pError, uiError );
hb_errPutFlags( pError, EF_CANDEFAULT );
uiError = SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return uiError == E_DEFAULT ? SUCCESS : FAILURE;
}
return SUCCESS;
}
| sdf1.c | 467 |
| STATIC ERRCODE | hb_sdfPutRec( SDFAREAP pArea, BYTE * pBuffer )
static ERRCODE hb_sdfPutRec( SDFAREAP pArea, BYTE * pBuffer )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfPutRec(%p,%p)", pArea, pBuffer));
if( !pArea->fPositioned )
return SUCCESS;
if( !pArea->fRecordChanged )
return FAILURE;
/* Copy data to buffer */
memcpy( pArea->pRecord, pBuffer + 1, pArea->uiRecordLen );
return SUCCESS;
}
| sdf1.c | 566 |
| STATIC ERRCODE | hb_sdfGetRec( SDFAREAP pArea, BYTE ** pBufferPtr )
static ERRCODE hb_sdfGetRec( SDFAREAP pArea, BYTE ** pBufferPtr )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfGetRec(%p,%p)", pArea, pBufferPtr));
*pBufferPtr = pArea->pRecord - 1;
return SUCCESS;
}
| sdf1.c | 585 |
| STATIC ERRCODE | hb_sdfTrans( SDFAREAP pArea, LPDBTRANSINFO pTransInfo )
static ERRCODE hb_sdfTrans( SDFAREAP pArea, LPDBTRANSINFO pTransInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfTrans(%p, %p)", pArea, pTransInfo));
if( pTransInfo->uiFlags & DBTF_MATCH )
{
if( !pArea->fTransRec || pArea->cdPage != pTransInfo->lpaDest->cdPage )
pTransInfo->uiFlags &= ~DBTF_PUTREC;
else if( pArea->rddID == pTransInfo->lpaDest->rddID )
pTransInfo->uiFlags |= DBTF_PUTREC;
else
{
PHB_ITEM pPutRec = hb_itemPutL( NULL, FALSE );
if( SELF_INFO( ( AREAP ) pTransInfo->lpaDest, DBI_CANPUTREC, pPutRec ) != SUCCESS )
{
hb_itemRelease( pPutRec );
return FAILURE;
}
if( hb_itemGetL( pPutRec ) )
pTransInfo->uiFlags |= DBTF_PUTREC;
else
pTransInfo->uiFlags &= ~DBTF_PUTREC;
hb_itemRelease( pPutRec );
}
}
return SUPER_TRANS( ( AREAP ) pArea, pTransInfo );
}
| sdf1.c | 597 |
| STATIC ERRCODE | hb_sdfGoCold( SDFAREAP pArea )
static ERRCODE hb_sdfGoCold( SDFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfGoCold(%p)", pArea));
if( pArea->fRecordChanged )
{
ULONG ulWrite = pArea->uiRecordLen + pArea->uiEolLen;
if( hb_fileWriteAt( pArea->pFile, pArea->pRecord, ulWrite,
pArea->ulRecordOffset ) != ulWrite )
{
PHB_ITEM pError = hb_errNew();
hb_errPutGenCode( pError, EG_WRITE );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_WRITE ) );
hb_errPutSubCode( pError, EDBF_WRITE );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutFileName( pError, pArea->szFileName );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
pArea->ulFileSize += ulWrite;
pArea->ulNextOffset = pArea->ulFileSize;
pArea->fRecordChanged = FALSE;
pArea->fFlush = TRUE;
}
return SUCCESS;
}
| sdf1.c | 628 |
| STATIC ERRCODE | hb_sdfGoHot( SDFAREAP pArea )
static ERRCODE hb_sdfGoHot( SDFAREAP pArea )
{
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_sdfGoHot(%p)", pArea));
if( pArea->fReadonly )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_READONLY );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_READONLY ) );
hb_errPutSubCode( pError, EDBF_READONLY );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
pArea->fRecordChanged = TRUE;
return SUCCESS;
}
| sdf1.c | 661 |
| STATIC ERRCODE | hb_sdfFlush( SDFAREAP pArea )
static ERRCODE hb_sdfFlush( SDFAREAP pArea )
{
ERRCODE uiError;
HB_TRACE(HB_TR_DEBUG, ("hb_sdfFlush(%p)", pArea));
uiError = SELF_GOCOLD( ( AREAP ) pArea );
if( pArea->fFlush )
{
hb_fileWriteAt( pArea->pFile, ( BYTE * ) "\032", 1, pArea->ulFileSize );
if( hb_setGetHardCommit() )
{
hb_fileCommit( pArea->pFile );
pArea->fFlush = FALSE;
}
}
return uiError;
}
| sdf1.c | 684 |
| STATIC ERRCODE | hb_sdfInfo( SDFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
static ERRCODE hb_sdfInfo( SDFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfInfo(%p,%hu,%p)", pArea, uiIndex, pItem));
switch( uiIndex )
{
case DBI_CANPUTREC:
hb_itemPutL( pItem, pArea->fTransRec );
break;
case DBI_GETRECSIZE:
hb_itemPutNL( pItem, pArea->uiRecordLen );
break;
case DBI_FULLPATH:
hb_itemPutC( pItem, pArea->szFileName);
break;
case DBI_FILEHANDLE:
hb_itemPutNInt( pItem, ( HB_NHANDLE ) hb_fileHandle( pArea->pFile ) );
break;
case DBI_SHARED:
hb_itemPutL( pItem, pArea->fShared );
break;
case DBI_ISREADONLY:
hb_itemPutL( pItem, pArea->fReadonly );
break;
case DBI_POSITIONED:
hb_itemPutL( pItem, pArea->fPositioned );
break;
case DBI_DB_VERSION:
case DBI_RDD_VERSION:
{
char szBuf[ 64 ];
int iSub = hb_itemGetNI( pItem );
if( iSub == 1 )
snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s)", 0, 1, "SDF" );
else if( iSub == 2 )
snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s:%d)", 0, 1, "SDF", pArea->rddID );
else
snprintf( szBuf, sizeof( szBuf ), "%d.%d", 0, 1 );
hb_itemPutC( pItem, szBuf );
break;
}
default:
return SUPER_INFO( ( AREAP ) pArea, uiIndex, pItem );
}
return SUCCESS;
}
| sdf1.c | 708 |
| STATIC ERRCODE | hb_sdfAddField( SDFAREAP pArea, LPDBFIELDINFO pFieldInfo )
static ERRCODE hb_sdfAddField( SDFAREAP pArea, LPDBFIELDINFO pFieldInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfAddField(%p, %p)", pArea, pFieldInfo));
switch( pFieldInfo->uiType )
{
case HB_FT_MEMO:
case HB_FT_IMAGE:
case HB_FT_BLOB:
case HB_FT_OLE:
pFieldInfo->uiType = HB_FT_MEMO;
pFieldInfo->uiLen = 0;
pArea->fTransRec = FALSE;
break;
case HB_FT_ANY:
if( pFieldInfo->uiLen == 3 )
{
pFieldInfo->uiType = HB_FT_DATE;
pFieldInfo->uiLen = 8;
}
else if( pFieldInfo->uiLen < 6 )
{
pFieldInfo->uiType = HB_FT_LONG;
pFieldInfo->uiLen = s_uiNumLength[ pFieldInfo->uiLen ];
}
else
{
pFieldInfo->uiType = HB_FT_MEMO;
pFieldInfo->uiLen = 0;
}
pArea->fTransRec = FALSE;
break;
case HB_FT_DATE:
if( pFieldInfo->uiLen != 8 )
{
pFieldInfo->uiLen = 8;
pArea->fTransRec = FALSE;
}
break;
case HB_FT_FLOAT:
pFieldInfo->uiType = HB_FT_LONG;
break;
case HB_FT_INTEGER:
case HB_FT_CURRENCY:
case HB_FT_ROWVER:
case HB_FT_AUTOINC:
pFieldInfo->uiType = HB_FT_LONG;
pFieldInfo->uiLen = s_uiNumLength[ pFieldInfo->uiLen ];
if( pFieldInfo->uiDec )
pFieldInfo->uiLen++;
pArea->fTransRec = FALSE;
break;
case HB_FT_DOUBLE:
case HB_FT_CURDOUBLE:
pFieldInfo->uiType = HB_FT_LONG;
pFieldInfo->uiLen = 20;
pArea->fTransRec = FALSE;
break;
case HB_FT_VARLENGTH:
pFieldInfo->uiType = HB_FT_STRING;
pArea->fTransRec = FALSE;
break;
case HB_FT_LOGICAL:
if( pFieldInfo->uiLen != 1 )
{
pFieldInfo->uiLen = 1;
pArea->fTransRec = FALSE;
}
break;
case HB_FT_LONG:
case HB_FT_STRING:
break;
case HB_FT_DAYTIME:
case HB_FT_MODTIME:
pFieldInfo->uiType = HB_FT_STRING;
pFieldInfo->uiLen = 23;
pArea->fTransRec = FALSE;
break;
default:
pFieldInfo->uiType = HB_FT_NONE;
pFieldInfo->uiLen = 0;
pArea->fTransRec = FALSE;
break;
}
/* Update field offset */
pArea->pFieldOffset[ pArea->uiFieldCount ] = pArea->uiRecordLen;
pArea->uiRecordLen += pFieldInfo->uiLen;
return SUPER_ADDFIELD( ( AREAP ) pArea, pFieldInfo );
}
| sdf1.c | 768 |
| STATIC ERRCODE | hb_sdfSetFieldExtent( SDFAREAP pArea, USHORT uiFieldExtent )
static ERRCODE hb_sdfSetFieldExtent( SDFAREAP pArea, USHORT uiFieldExtent )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfSetFieldExtent(%p,%hu)", pArea, uiFieldExtent));
if( SUPER_SETFIELDEXTENT( ( AREAP ) pArea, uiFieldExtent ) == FAILURE )
return FAILURE;
/* Alloc field offsets array */
if( uiFieldExtent )
{
pArea->pFieldOffset = ( USHORT * ) hb_xgrab( uiFieldExtent * sizeof( USHORT ) );
memset( pArea->pFieldOffset, 0, uiFieldExtent * sizeof( USHORT ) );
}
return SUCCESS;
}
| sdf1.c | 873 |
| STATIC ERRCODE | hb_sdfNewArea( SDFAREAP pArea )
static ERRCODE hb_sdfNewArea( SDFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfNewArea(%p)", pArea));
if( SUPER_NEW( ( AREAP ) pArea ) == FAILURE )
return FAILURE;
pArea->pFile = NULL;
pArea->fTransRec = TRUE;
pArea->uiRecordLen = 0;
return SUCCESS;
}
| sdf1.c | 893 |
| STATIC ERRCODE | hb_sdfStructSize( SDFAREAP pArea, USHORT * uiSize )
static ERRCODE hb_sdfStructSize( SDFAREAP pArea, USHORT * uiSize )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfStrucSize(%p,%p)", pArea, uiSize));
HB_SYMBOL_UNUSED( pArea );
* uiSize = sizeof( SDFAREA );
return SUCCESS;
}
| sdf1.c | 910 |
| STATIC ERRCODE | hb_sdfClose( SDFAREAP pArea )
static ERRCODE hb_sdfClose( SDFAREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfClose(%p)", pArea));
SUPER_CLOSE( ( AREAP ) pArea );
/* Update record and unlock records */
if( pArea->pFile )
{
SELF_FLUSH( ( AREAP ) pArea );
hb_fileClose( pArea->pFile );
pArea->pFile = NULL;
}
if( pArea->pFieldOffset )
{
hb_xfree( pArea->pFieldOffset );
pArea->pFieldOffset = NULL;
}
if( pArea->pRecord )
{
hb_xfree( pArea->pRecord - 1 );
pArea->pRecord = NULL;
}
if( pArea->szEol )
{
hb_xfree( pArea->szEol );
pArea->szEol = NULL;
}
if( pArea->szFileName )
{
hb_xfree( pArea->szFileName );
pArea->szFileName = NULL;
}
return SUCCESS;
}
| sdf1.c | 922 |
| STATIC ERRCODE | hb_sdfCreate( SDFAREAP pArea, LPDBOPENINFO pCreateInfo )
static ERRCODE hb_sdfCreate( SDFAREAP pArea, LPDBOPENINFO pCreateInfo )
{
ERRCODE errCode;
PHB_FNAME pFileName;
PHB_ITEM pError = NULL;
BOOL fRetry;
BYTE szFileName[ _POSIX_PATH_MAX + 1 ];
HB_TRACE(HB_TR_DEBUG, ("hb_sdfCreate(%p,%p)", pArea, pCreateInfo));
pArea->fShared = FALSE; /* pCreateInfo->fShared; */
pArea->fReadonly = FALSE; /* pCreateInfo->fReadonly */
#ifndef HB_CDP_SUPPORT_OFF
if( pCreateInfo->cdpId )
{
pArea->cdPage = hb_cdpFind( (char *) pCreateInfo->cdpId );
if( !pArea->cdPage )
pArea->cdPage = hb_vmCDP();
}
else
pArea->cdPage = hb_vmCDP();
#endif
pFileName = hb_fsFNameSplit( ( char * ) pCreateInfo->abName );
if( hb_setGetDefExtension() && ! pFileName->szExtension )
{
PHB_ITEM pItem = hb_itemPutC( NULL, NULL );
SELF_INFO( ( AREAP ) pArea, DBI_TABLEEXT, pItem );
pFileName->szExtension = hb_itemGetCPtr( pItem );
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
hb_itemRelease( pItem );
}
else
{
hb_strncpy( ( char * ) szFileName, ( char * ) pCreateInfo->abName, sizeof( szFileName ) - 1 );
}
hb_xfree( pFileName );
/* Try create */
do
{
pArea->pFile = hb_fileExtOpen( szFileName, NULL,
FO_READWRITE | FO_EXCLUSIVE | FXO_TRUNCATE |
FXO_DEFAULTS | FXO_SHARELOCK | FXO_COPYNAME,
NULL, pError );
if( !pArea->pFile )
{
if( !pError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_CREATE );
hb_errPutSubCode( pError, EDBF_CREATE_DBF );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CREATE ) );
hb_errPutFileName( pError, ( char * ) szFileName );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
}
fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
}
else
fRetry = FALSE;
}
while( fRetry );
if( pError )
hb_itemRelease( pError );
if( !pArea->pFile )
return FAILURE;
errCode = SUPER_CREATE( ( AREAP ) pArea, pCreateInfo );
if( errCode != SUCCESS )
{
SELF_CLOSE( ( AREAP ) pArea );
return errCode;
}
hb_sdfInitArea( pArea, ( char * ) szFileName );
/* Position cursor at the first record */
return SELF_GOTOP( ( AREAP ) pArea );
}
| sdf1.c | 963 |
| STATIC ERRCODE | hb_sdfOpen( SDFAREAP pArea, LPDBOPENINFO pOpenInfo )
static ERRCODE hb_sdfOpen( SDFAREAP pArea, LPDBOPENINFO pOpenInfo )
{
PHB_ITEM pError = NULL;
PHB_FNAME pFileName;
ERRCODE errCode;
USHORT uiFlags;
BOOL fRetry;
BYTE szFileName[ _POSIX_PATH_MAX + 1 ];
char szAlias[ HB_RDD_MAX_ALIAS_LEN + 1 ];
HB_TRACE(HB_TR_DEBUG, ("hb_sdfOpen(%p,%p)", pArea, pOpenInfo));
pArea->fShared = TRUE; /* pOpenInfo->fShared; */
pArea->fReadonly = TRUE; /* pOpenInfo->fReadonly; */
#ifndef HB_CDP_SUPPORT_OFF
if( pOpenInfo->cdpId )
{
pArea->cdPage = hb_cdpFind( (char *) pOpenInfo->cdpId );
if( !pArea->cdPage )
pArea->cdPage = hb_vmCDP();
}
else
pArea->cdPage = hb_vmCDP();
#endif
uiFlags = ( pArea->fReadonly ? FO_READ : FO_READWRITE ) |
( pArea->fShared ? FO_DENYNONE : FO_EXCLUSIVE );
pFileName = hb_fsFNameSplit( ( char * ) pOpenInfo->abName );
/* Add default file name extension if necessary */
if( hb_setGetDefExtension() && ! pFileName->szExtension )
{
PHB_ITEM pFileExt = hb_itemPutC( NULL, NULL );
SELF_INFO( ( AREAP ) pArea, DBI_TABLEEXT, pFileExt );
pFileName->szExtension = hb_itemGetCPtr( pFileExt );
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
hb_itemRelease( pFileExt );
}
else
{
hb_strncpy( ( char * ) szFileName, ( char * ) pOpenInfo->abName, sizeof( szFileName ) - 1 );
}
/* Create default alias if necessary */
if( !pOpenInfo->atomAlias && pFileName->szName )
{
hb_strncpyUpperTrim( szAlias, pFileName->szName, sizeof( szAlias ) - 1 );
pOpenInfo->atomAlias = ( BYTE * ) szAlias;
}
hb_xfree( pFileName );
/* Try open */
do
{
pArea->pFile = hb_fileExtOpen( szFileName, NULL, uiFlags |
FXO_DEFAULTS | FXO_SHARELOCK | FXO_COPYNAME,
NULL, pError );
if( !pArea->pFile )
{
if( !pError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_OPEN );
hb_errPutSubCode( pError, EDBF_OPEN_DBF );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_OPEN ) );
hb_errPutFileName( pError, ( char * ) szFileName );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
}
fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
}
else
fRetry = FALSE;
}
while( fRetry );
if( pError )
hb_itemRelease( pError );
if( !pArea->pFile )
return FAILURE;
errCode = SUPER_OPEN( ( AREAP ) pArea, pOpenInfo );
if( errCode != SUCCESS )
{
SELF_CLOSE( ( AREAP ) pArea );
return FAILURE;
}
hb_sdfInitArea( pArea, ( char * ) szFileName );
/* Position cursor at the first record */
return SELF_GOTOP( ( AREAP ) pArea );
}
| sdf1.c | 1049 |
| STATIC ERRCODE | hb_sdfRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem )
static ERRCODE hb_sdfRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_sdfRddInfo(%p,%hu,%lu,%p)", pRDD, uiIndex, ulConnect, pItem));
switch( uiIndex )
{
case RDDI_CANPUTREC:
case RDDI_LOCAL:
hb_itemPutL( pItem, TRUE );
break;
case RDDI_TABLEEXT:
hb_itemPutC( pItem, SDF_TABLEEXT );
break;
default:
return SUPER_RDDINFO( pRDD, uiIndex, ulConnect, pItem );
}
return SUCCESS;
}
static const RDDFUNCS sdfTable = { NULL /* hb_sdfBof */,
NULL /* hb_sdfEof */,
NULL /* hb_sdfFound */,
NULL /* hb_sdfGoBottom */,
NULL /* hb_sdfGoTo */,
NULL /* hb_sdfGoToId */,
( DBENTRYP_V ) hb_sdfGoTop,
NULL /* hb_sdfSeek */,
NULL /* hb_sdfSkip */,
NULL /* hb_sdfSkipFilter */,
( DBENTRYP_L ) hb_sdfSkipRaw,
( DBENTRYP_VF ) hb_sdfAddField,
( DBENTRYP_B ) hb_sdfAppend,
NULL /* hb_sdfCreateFields */,
( DBENTRYP_V ) hb_sdfDeleteRec,
( DBENTRYP_BP ) hb_sdfDeleted,
NULL /* hb_sdfFieldCount */,
NULL /* hb_sdfFieldDisplay */,
NULL /* hb_sdfFieldInfo */,
NULL /* hb_sdfFieldName */,
( DBENTRYP_V ) hb_sdfFlush,
( DBENTRYP_PP ) hb_sdfGetRec,
( DBENTRYP_SI ) hb_sdfGetValue,
NULL /* hb_sdfGetVarLen */,
( DBENTRYP_V ) hb_sdfGoCold,
( DBENTRYP_V ) hb_sdfGoHot,
( DBENTRYP_P ) hb_sdfPutRec,
( DBENTRYP_SI ) hb_sdfPutValue,
NULL /* hb_sdfRecall */,
( DBENTRYP_ULP ) hb_sdfRecCount,
NULL /* hb_sdfRecInfo */,
( DBENTRYP_ULP ) hb_sdfRecNo,
( DBENTRYP_I ) hb_sdfRecId,
( DBENTRYP_S ) hb_sdfSetFieldExtent,
NULL /* hb_sdfAlias */,
( DBENTRYP_V ) hb_sdfClose,
( DBENTRYP_VP ) hb_sdfCreate,
( DBENTRYP_SI ) hb_sdfInfo,
( DBENTRYP_V ) hb_sdfNewArea,
( DBENTRYP_VP ) hb_sdfOpen,
NULL /* hb_sdfRelease */,
( DBENTRYP_SP ) hb_sdfStructSize,
NULL /* hb_sdfSysName */,
NULL /* hb_sdfEval */,
NULL /* hb_sdfPack */,
NULL /* hb_sdfPackRec */,
NULL /* hb_sdfSort */,
( DBENTRYP_VT ) hb_sdfTrans,
NULL /* hb_sdfTransRec */,
NULL /* hb_sdfZap */,
NULL /* hb_sdfChildEnd */,
NULL /* hb_sdfChildStart */,
NULL /* hb_sdfChildSync */,
NULL /* hb_sdfSyncChildren */,
NULL /* hb_sdfClearRel */,
NULL /* hb_sdfForceRel */,
NULL /* hb_sdfRelArea */,
NULL /* hb_sdfRelEval */,
NULL /* hb_sdfRelText */,
NULL /* hb_sdfSetRel */,
NULL /* hb_sdfOrderListAdd */,
NULL /* hb_sdfOrderListClear */,
NULL /* hb_sdfOrderListDelete */,
NULL /* hb_sdfOrderListFocus */,
NULL /* hb_sdfOrderListRebuild */,
NULL /* hb_sdfOrderCondition */,
NULL /* hb_sdfOrderCreate */,
NULL /* hb_sdfOrderDestroy */,
NULL /* hb_sdfOrderInfo */,
NULL /* hb_sdfClearFilter */,
NULL /* hb_sdfClearLocate */,
NULL /* hb_sdfClearScope */,
NULL /* hb_sdfCountScope */,
NULL /* hb_sdfFilterText */,
NULL /* hb_sdfScopeInfo */,
NULL /* hb_sdfSetFilter */,
NULL /* hb_sdfSetLocate */,
NULL /* hb_sdfSetScope */,
NULL /* hb_sdfSkipScope */,
NULL /* hb_sdfLocate */,
NULL /* hb_sdfCompile */,
NULL /* hb_sdfError */,
NULL /* hb_sdfEvalBlock */,
NULL /* hb_sdfRawLock */,
NULL /* hb_sdfLock */,
NULL /* hb_sdfUnLock */,
NULL /* hb_sdfCloseMemFile */,
NULL /* hb_sdfCreateMemFile */,
NULL /* hb_sdfGetValueFile */,
NULL /* hb_sdfOpenMemFile */,
NULL /* hb_sdfPutValueFile */,
NULL /* hb_sdfReadDBHeader */,
NULL /* hb_sdfWriteDBHeader */,
NULL /* hb_sdfInit */,
NULL /* hb_sdfExit */,
NULL /* hb_sdfDrop */,
NULL /* hb_sdfExists */,
( DBENTRYP_RSLV ) hb_sdfRddInfo,
NULL /* hb_sdfWhoCares */
};
HB_FUNC( SDF ) { ; }
| sdf1.c | 1147 |
| } | HB_FUNC( SDF_GETFUNCTABLE )
HB_FUNC( SDF_GETFUNCTABLE )
{
RDDFUNCS * pTable;
USHORT * uiCount;
uiCount = ( USHORT * ) hb_parptr( 1 );
pTable = ( RDDFUNCS * ) hb_parptr( 2 );
HB_TRACE(HB_TR_DEBUG, ("SDF_GETFUNCTABLE(%p, %p)", uiCount, pTable));
if( pTable )
{
if( uiCount )
* uiCount = RDDFUNCSCOUNT;
hb_retni( hb_rddInherit( pTable, &sdfTable, &sdfSuper, NULL ) );
}
else
hb_retni( FAILURE );
}
| sdf1.c | 1277 |
| STATIC VOID | hb_sdfRddInit( void * cargo )
static void hb_sdfRddInit( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
if( hb_rddRegister( "SDF", RDT_TRANSFER ) > 1 )
{
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
}
}
| sdf1.c | 1305 |
| HB_INIT_SYMBOLS_BEGIN( | sdf1__InitSymbols )
HB_INIT_SYMBOLS_BEGIN( sdf1__InitSymbols )
{ "SDF", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( SDF )}, NULL },
{ "SDF_GETFUNCTABLE", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( SDF_GETFUNCTABLE )}, NULL }
HB_INIT_SYMBOLS_END( sdf1__InitSymbols )
HB_CALL_ON_STARTUP_BEGIN( _hb_sdf_rdd_init_ )
hb_vmAtInit( hb_sdfRddInit, NULL );
HB_CALL_ON_STARTUP_END( _hb_sdf_rdd_init_ )
#if defined( HB_PRAGMA_STARTUP )
#pragma startup sdf1__InitSymbols
#pragma startup _hb_sdf_rdd_init_
#elif defined( HB_MSC_STARTUP )
#if defined( HB_OS_WIN_64 )
#pragma section( HB_MSC_START_SEGMENT, long, read )
#endif
#pragma data_seg( HB_MSC_START_SEGMENT )
static HB_$INITSYM hb_vm_auto_sdf1__InitSymbols = sdf1__InitSymbols;
static HB_$INITSYM hb_vm_auto_sdf_rdd_init = _hb_sdf_rdd_init_;
| sdf1.c | 1315 |
| wacore.c |
| Type | Function | Source | Line |
|---|
| STATIC VOID | hb_waNodeInsert( PHB_STACKRDD pRddInfo, AREAP pArea )
static void hb_waNodeInsert( PHB_STACKRDD pRddInfo, AREAP pArea )
{
USHORT uiWaPos;
if( pRddInfo->uiCurrArea >= pRddInfo->uiWaNumMax )
{
int iSize = ( ( ( int ) pRddInfo->uiCurrArea + 256 ) >> 8 ) << 8;
if( iSize > HB_RDD_MAX_AREA_NUM )
iSize = HB_RDD_MAX_AREA_NUM;
if( pRddInfo->uiWaNumMax == 0 )
{
pRddInfo->waNums = (USHORT *) hb_xgrab( iSize * sizeof(USHORT) );
}
else
{
pRddInfo->waNums = (USHORT *) hb_xrealloc( pRddInfo->waNums, iSize * sizeof(USHORT) );
}
memset( &pRddInfo->waNums[ pRddInfo->uiWaNumMax ], 0, ( iSize - pRddInfo->uiWaNumMax ) * sizeof(USHORT) );
pRddInfo->uiWaNumMax = iSize;
}
if( pRddInfo->uiWaSpace == 0 )
{
pRddInfo->uiWaSpace = 256;
pRddInfo->waList = ( void ** ) hb_xgrab( pRddInfo->uiWaSpace * sizeof(void *) );
memset( &pRddInfo->waList[ 0 ], 0, pRddInfo->uiWaSpace * sizeof(void *) );
pRddInfo->waList[ 0 ] = NULL;
uiWaPos = 1;
pRddInfo->uiWaMax = 2;
}
else
{
uiWaPos = pRddInfo->uiWaMax++;
if( pRddInfo->uiWaMax > pRddInfo->uiWaSpace )
{
pRddInfo->uiWaSpace = ( ( pRddInfo->uiWaMax + 256 ) >> 8 ) << 8;
pRddInfo->waList = ( void ** ) hb_xrealloc( pRddInfo->waList, pRddInfo->uiWaSpace * sizeof(void *) );
memset( &pRddInfo->waList[ pRddInfo->uiWaMax ], 0, ( pRddInfo->uiWaSpace - pRddInfo->uiWaMax ) * sizeof(void *) );
}
while( uiWaPos > 1 )
{
if( ( ( AREAP ) pRddInfo->waList[ uiWaPos - 1 ] )->uiArea < pRddInfo->uiCurrArea )
break;
pRddInfo->waList[ uiWaPos ] = pRddInfo->waList[ uiWaPos - 1 ];
pRddInfo->waNums[ ( ( AREAP ) pRddInfo->waList[ uiWaPos ] )->uiArea ] = uiWaPos;
uiWaPos--;
}
}
pRddInfo->waNums[ pRddInfo->uiCurrArea ] = uiWaPos;
pRddInfo->pCurrArea = pRddInfo->waList[ uiWaPos ] = pArea;
pArea->uiArea = pRddInfo->uiCurrArea;
}
| wacore.c | 72 |
| STATIC VOID | hb_waNodeDelete( PHB_STACKRDD pRddInfo )
static void hb_waNodeDelete( PHB_STACKRDD pRddInfo )
{
USHORT uiWaPos;
uiWaPos = pRddInfo->waNums[ pRddInfo->uiCurrArea ];
pRddInfo->waNums[ pRddInfo->uiCurrArea ] = 0;
pRddInfo->uiWaMax--;
if( pRddInfo->uiWaMax <= 1 )
{
pRddInfo->uiWaSpace = pRddInfo->uiWaMax = pRddInfo->uiWaNumMax = 0;
hb_xfree( pRddInfo->waList );
hb_xfree( pRddInfo->waNums );
pRddInfo->waList = NULL;
pRddInfo->waNums = NULL;
}
else
{
while( uiWaPos < pRddInfo->uiWaMax )
{
pRddInfo->waList[ uiWaPos ] = pRddInfo->waList[ uiWaPos + 1 ];
pRddInfo->waNums[ ( ( AREAP ) pRddInfo->waList[ uiWaPos ] )->uiArea ] = uiWaPos;
uiWaPos++;
}
pRddInfo->waList[ pRddInfo->uiWaMax ] = NULL;
if( pRddInfo->uiWaSpace - pRddInfo->uiWaMax >= 256 )
{
pRddInfo->uiWaSpace = ( ( pRddInfo->uiWaMax + 256 ) >> 8 ) << 8;
pRddInfo->waList = ( void ** ) hb_xrealloc( pRddInfo->waList, pRddInfo->uiWaSpace * sizeof( void * ) );
}
}
pRddInfo->pCurrArea = NULL;
}
| wacore.c | 130 |
| HB_EXPORT ERRCODE | hb_rddSelectFirstAvailable( void )
HB_EXPORT ERRCODE hb_rddSelectFirstAvailable( void )
{
PHB_STACKRDD pRddInfo;
USHORT uiArea;
HB_TRACE(HB_TR_DEBUG, ("hb_rddSelectFirstAvailable()"));
pRddInfo = hb_stackRDD();
uiArea = 1;
while( uiArea < pRddInfo->uiWaNumMax )
{
if( pRddInfo->waNums[ uiArea ] == 0 )
break;
uiArea++;
}
if( uiArea >= HB_RDD_MAX_AREA_NUM )
return FAILURE;
HB_SET_WA( uiArea );
return SUCCESS;
}
| wacore.c | 166 |
| HB_EXPORT USHORT | hb_rddInsertAreaNode( const char *szDriver )
HB_EXPORT USHORT hb_rddInsertAreaNode( const char *szDriver )
{
PHB_STACKRDD pRddInfo;
LPRDDNODE pRddNode;
USHORT uiRddID;
AREAP pArea;
HB_TRACE(HB_TR_DEBUG, ("hb_rddInsertAreaNode(%s)", szDriver));
pRddInfo = hb_stackRDD();
if( pRddInfo->uiCurrArea && pRddInfo->pCurrArea )
return 0;
pRddNode = hb_rddFindNode( szDriver, &uiRddID );
if( !pRddNode )
return 0;
pArea = ( AREAP ) hb_rddNewAreaNode( pRddNode, uiRddID );
if( !pArea )
return 0;
if( pRddInfo->uiCurrArea == 0 )
{
if( hb_rddSelectFirstAvailable() != SUCCESS )
return 0;
}
hb_waNodeInsert( pRddInfo, pArea );
return pRddInfo->uiCurrArea;
}
| wacore.c | 191 |
| HB_EXPORT VOID | hb_rddReleaseCurrentArea( void )
HB_EXPORT void hb_rddReleaseCurrentArea( void )
{
PHB_STACKRDD pRddInfo;
AREAP pArea;
HB_TRACE(HB_TR_DEBUG, ("hb_rddReleaseCurrentArea()"));
pRddInfo = hb_stackRDD();
pArea = ( AREAP ) pRddInfo->pCurrArea;
if( !pArea )
return;
if( SELF_CLOSE( pArea ) == FAILURE )
return;
SELF_RELEASE( pArea );
hb_waNodeDelete( pRddInfo );
}
| wacore.c | 226 |
| HB_EXPORT VOID | hb_rddCloseAll( void )
HB_EXPORT void hb_rddCloseAll( void )
{
PHB_STACKRDD pRddInfo;
HB_TRACE(HB_TR_DEBUG, ("hb_rddCloseAll()"));
pRddInfo = hb_stackRDD();
if( pRddInfo->uiWaMax > 0 )
{
BOOL isParents, isFinish = FALSE;
AREAP pArea;
USHORT uiIndex;
do
{
isParents = FALSE;
for( uiIndex = 1; uiIndex < pRddInfo->uiWaMax; uiIndex++ )
{
pArea = ( AREAP ) pRddInfo->waList[ uiIndex ];
HB_SET_WA( pArea->uiArea );
if( isFinish )
{
SELF_RELEASE( pArea );
pRddInfo->waNums[ pRddInfo->uiCurrArea ] = 0;
pRddInfo->pCurrArea = NULL;
}
else if( pArea->uiParents )
{
isParents = TRUE;
}
else
{
SELF_CLOSE( pArea );
}
}
if( !isParents && !isFinish )
{
isParents = isFinish = TRUE;
}
}
while( isParents );
pRddInfo->uiWaSpace = pRddInfo->uiWaMax = pRddInfo->uiWaNumMax = 0;
hb_xfree( pRddInfo->waList );
hb_xfree( pRddInfo->waNums );
pRddInfo->waList = NULL;
pRddInfo->waNums = NULL;
HB_SET_WA( 1 );
}
}
| wacore.c | 250 |
| HB_EXPORT VOID | hb_rddFlushAll( void )
HB_EXPORT void hb_rddFlushAll( void )
{
PHB_STACKRDD pRddInfo = hb_stackRDD();
USHORT uiArea = hb_rddGetCurrentWorkAreaNumber(), uiIndex;
for( uiIndex = 1; uiIndex < pRddInfo->uiWaMax; ++uiIndex )
{
hb_rddSelectWorkAreaNumber( ( ( AREAP ) pRddInfo->waList[ uiIndex ] )->uiArea );
SELF_FLUSH( ( AREAP ) pRddInfo->pCurrArea );
}
hb_rddSelectWorkAreaNumber( uiArea );
}
| wacore.c | 304 |
| HB_EXPORT VOID | hb_rddUnLockAll( void )
HB_EXPORT void hb_rddUnLockAll( void )
{
PHB_STACKRDD pRddInfo = hb_stackRDD();
USHORT uiArea = hb_rddGetCurrentWorkAreaNumber(), uiIndex;
for( uiIndex = 1; uiIndex < pRddInfo->uiWaMax; ++uiIndex )
{
hb_rddSelectWorkAreaNumber( ( ( AREAP ) pRddInfo->waList[ uiIndex ] )->uiArea );
SELF_UNLOCK( ( AREAP ) pRddInfo->pCurrArea, NULL );
}
hb_rddSelectWorkAreaNumber( uiArea );
}
| wacore.c | 317 |
| HB_EXPORT ERRCODE | hb_rddIterateWorkAreas( WACALLBACK pCallBack, void * cargo )
HB_EXPORT ERRCODE hb_rddIterateWorkAreas( WACALLBACK pCallBack, void * cargo )
{
PHB_STACKRDD pRddInfo;
ERRCODE errCode = SUCCESS;
USHORT uiIndex;
HB_TRACE(HB_TR_DEBUG, ("hb_rddIterateWorkAreas(%p,%p)", pCallBack, cargo));
pRddInfo = hb_stackRDD();
for( uiIndex = 1; uiIndex < pRddInfo->uiWaMax; uiIndex++ )
{
errCode = pCallBack( ( AREAP ) pRddInfo->waList[ uiIndex ], cargo );
if( errCode != SUCCESS )
break;
}
return errCode;
}
| wacore.c | 330 |
| HB_EXPORT BOOL | hb_rddGetNetErr( void )
HB_EXPORT BOOL hb_rddGetNetErr( void )
{
return hb_stackRDD()->fNetError;
}
| wacore.c | 351 |
| HB_EXPORT VOID | hb_rddSetNetErr( BOOL fNetErr )
HB_EXPORT void hb_rddSetNetErr( BOOL fNetErr )
{
hb_stackRDD()->fNetError = fNetErr;
}
| wacore.c | 356 |
| HB_EXPORT CONST CHAR * | hb_rddDefaultDrv( const char * szDriver )
HB_EXPORT const char * hb_rddDefaultDrv( const char * szDriver )
{
PHB_STACKRDD pRddInfo = hb_stackRDD();
if( szDriver && *szDriver )
{
char szNewDriver[ HB_RDD_MAX_DRIVERNAME_LEN + 1 ];
USHORT uiRddID;
hb_strncpyUpper( szNewDriver, szDriver, sizeof( szNewDriver ) - 1 );
if( !hb_rddFindNode( szNewDriver, &uiRddID ) )
return NULL;
pRddInfo->szDefaultRDD = hb_rddGetNode( uiRddID )->szName;
}
else if( !pRddInfo->szDefaultRDD && hb_rddGetNode( 0 ) )
{
const char *szDrvTable[] = { "DBFNTX", "DBFCDX", "DBFFPT", "DBF", NULL };
int i;
pRddInfo->szDefaultRDD = "";
for( i = 0; szDrvTable[ i ]; ++i )
{
if( hb_rddFindNode( szDrvTable[ i ], NULL ) )
{
pRddInfo->szDefaultRDD = szDrvTable[ i ];
break;
}
}
}
return pRddInfo->szDefaultRDD;
}
| wacore.c | 361 |
| HB_EXPORT VOID * | hb_rddGetWorkAreaPointer( int iArea )
HB_EXPORT void * hb_rddGetWorkAreaPointer( int iArea )
{
PHB_STACKRDD pRddInfo;
HB_TRACE(HB_TR_DEBUG, ("hb_rddGetWorkAreaPointer(%d)", iArea));
pRddInfo = hb_stackRDD();
if( iArea == 0 )
return pRddInfo->pCurrArea;
else if( iArea >= 1 && ( UINT ) iArea < ( UINT ) pRddInfo->uiWaNumMax )
return pRddInfo->waList[ pRddInfo->waNums[ iArea ] ];
else
return NULL;
}
| wacore.c | 398 |
| HB_EXPORT VOID * | hb_rddGetCurrentWorkAreaPointer( void )
HB_EXPORT void * hb_rddGetCurrentWorkAreaPointer( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_rddGetCurrentWorkAreaPointer()"));
return hb_stackRDD()->pCurrArea;
}
| wacore.c | 417 |
| HB_EXPORT INT | hb_rddGetCurrentWorkAreaNumber( void )
HB_EXPORT int hb_rddGetCurrentWorkAreaNumber( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_rddGetCurrentWorkAreaNumber()"));
return hb_stackRDD()->uiCurrArea;
}
| wacore.c | 427 |
| HB_EXPORT ERRCODE | hb_rddSelectWorkAreaNumber( int iArea )
HB_EXPORT ERRCODE hb_rddSelectWorkAreaNumber( int iArea )
{
PHB_STACKRDD pRddInfo;
HB_TRACE(HB_TR_DEBUG, ("hb_rddSelectWorkAreaNumber(%d)", iArea));
pRddInfo = hb_stackRDD();
if( iArea < 1 || iArea > HB_RDD_MAX_AREA_NUM )
HB_SET_WA( 0 );
else
HB_SET_WA( iArea );
return ( pRddInfo->pCurrArea == NULL ) ? FAILURE : SUCCESS;
}
/* *********************************************************** */
/*
* Moving work ares between threads
*/
static HB_CRITICAL_NEW( s_waMtx );
static HB_COND_NEW( s_waCond );
static PHB_ITEM s_pDetachedAreas = NULL;
| wacore.c | 437 |
| STATIC HB_GARBAGE_FUNC( | hb_waHolderDestructor )
static HB_GARBAGE_FUNC( hb_waHolderDestructor )
{
AREAP * pHolder = ( AREAP * ) Cargo;
if( *pHolder )
{
AREAP pArea;
int iArea;
pArea = *pHolder;
*pHolder = NULL;
iArea = hb_rddGetCurrentWorkAreaNumber();
hb_rddSelectFirstAvailable();
hb_waNodeInsert( hb_stackRDD(), pArea );
hb_rddReleaseCurrentArea();
hb_rddSelectWorkAreaNumber( iArea );
}
}
| wacore.c | 466 |
| VOID | hb_rddCloseDetachedAreas( void )
void hb_rddCloseDetachedAreas( void )
{
PHB_ITEM pDetachedArea;
/* protect by critical section access to s_pDetachedAreas array */
hb_threadEnterCriticalSection( &s_waMtx );
pDetachedArea = s_pDetachedAreas;
s_pDetachedAreas = NULL;
/* leave critical section */
hb_threadLeaveCriticalSection( &s_waMtx );
/* release detached areas */
if( pDetachedArea )
hb_itemRelease( pDetachedArea );
}
| wacore.c | 488 |
| HB_EXPORT ERRCODE | hb_rddDetachArea( AREAP pArea, PHB_ITEM pCargo )
HB_EXPORT ERRCODE hb_rddDetachArea( AREAP pArea, PHB_ITEM pCargo )
{
AREAP * pHolder;
PHB_ITEM pDetachedArea;
ULONG ulPos;
int iArea;
HB_TRACE(HB_TR_DEBUG, ("hb_rddDetachArea(%p,%p)", pArea, pCargo));
/* save current WA number */
iArea = hb_rddGetCurrentWorkAreaNumber();
/* select given WA */
hb_rddSelectWorkAreaNumber( pArea->uiArea );
/* flush buffers */
SELF_GOCOLD( pArea );
/* remove all locks */
/* ??? is it xbase++ compatible? */
/* SELF_UNLOCK( pArea, NULL ); */
/* Clear all child and parent relations */
SELF_CLEARREL( pArea );
hb_rddCloseAllParentRelations( pArea );
/* detach WA and alias */
hb_waNodeDelete( hb_stackRDD() );
pArea->uiArea = 0;
if( pArea->atomAlias )
hb_dynsymSetAreaHandle( ( PHB_DYNS ) pArea->atomAlias, 0 );
/* restore previous WA number */
hb_rddSelectWorkAreaNumber( iArea );
/* protect by critical section access to s_pDetachedAreas array */
hb_threadEnterCriticalSection( &s_waMtx );
if( ! s_pDetachedAreas )
{
s_pDetachedAreas = hb_itemArrayNew( 1 );
ulPos = 1;
}
else
{
ulPos = hb_arrayLen( s_pDetachedAreas ) + 1;
hb_arraySize( s_pDetachedAreas, ulPos );
}
pDetachedArea = hb_arrayGetItemPtr( s_pDetachedAreas, ulPos );
hb_arrayNew( pDetachedArea, 2 );
if( pCargo )
hb_arraySet( pDetachedArea, 2, pCargo );
pHolder = ( AREAP * ) hb_gcAlloc( sizeof( AREAP ), hb_waHolderDestructor );
*pHolder = pArea;
hb_arraySetPtrGC( pDetachedArea, 1, pHolder );
/* siagnal waiting processes that new area is available */
hb_threadCondBroadcast( &s_waCond );
/* leave critical section */
hb_threadLeaveCriticalSection( &s_waMtx );
return SUCCESS;
}
| wacore.c | 503 |
| HB_EXPORT AREAP | hb_rddRequestArea( char * szAlias, PHB_ITEM pCargo, BOOL fNewArea, BOOL fWait )
HB_EXPORT AREAP hb_rddRequestArea( char * szAlias, PHB_ITEM pCargo,
BOOL fNewArea, BOOL fWait )
{
PHB_DYNS pSymAlias = NULL;
AREAP pArea = NULL;
if( pCargo )
hb_itemClear( pCargo );
/* close current WA or chose 1-st free available */
if( !fNewArea )
{
hb_rddReleaseCurrentArea();
}
else if( hb_rddSelectFirstAvailable() != SUCCESS )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return NULL;
}
if( szAlias )
{
pSymAlias = hb_dynsymFindName( szAlias );
/* verify if the alias name is valid symbol */
if( hb_rddVerifyAliasName( szAlias ) != SUCCESS )
{
hb_errRT_DBCMD_Ext( EG_BADALIAS, EDBCMD_BADALIAS, NULL, szAlias, EF_CANDEFAULT );
return NULL;
}
/* verify if the alias is already in use */
if( hb_dynsymAreaHandle( pSymAlias ) != 0 )
{
hb_errRT_DBCMD_Ext( EG_DUPALIAS, EDBCMD_DUPALIAS, NULL, szAlias, EF_CANDEFAULT );
return NULL;
}
}
/* protect by critical section access to s_pDetachedAreas array */
hb_threadEnterCriticalSection( &s_waMtx );
for( ;; )
{
if( s_pDetachedAreas )
{
ULONG ulLen = hb_arrayLen( s_pDetachedAreas ), ulPos = 1;
if( pSymAlias )
{
for( ulPos = 1; ulPos <= ulLen; ++ulPos )
{
AREAP * pDetachedArea = ( AREAP * )
hb_arrayGetPtr( hb_arrayGetItemPtr( s_pDetachedAreas, ulPos ), 1 );
if( pSymAlias == ( PHB_DYNS ) ( *pDetachedArea )->atomAlias )
break;
}
}
if( ulPos <= ulLen )
{
PHB_ITEM pArray = hb_arrayGetItemPtr( s_pDetachedAreas, ulPos );
AREAP * pDetachedArea = ( AREAP * ) hb_arrayGetPtr( pArray, 1 );
pArea = *pDetachedArea;
*pDetachedArea = NULL;
if( pCargo )
hb_arrayGet( pArray, 2, pCargo );
hb_arrayDel( s_pDetachedAreas, ulPos );
hb_arraySize( s_pDetachedAreas, ulLen - 1 );
}
}
if( pArea || !fWait )
break;
hb_vmUnlock();
/* wait for detached workareas */
hb_threadCondWait( &s_waCond, &s_waMtx );
hb_vmLock();
if( hb_vmRequestQuery() != 0 )
break;
}
/* leave critical section */
hb_threadLeaveCriticalSection( &s_waMtx );
/* atach WA and set alias */
if( pArea )
{
hb_waNodeInsert( hb_stackRDD(), pArea );
if( pArea->atomAlias )
hb_dynsymSetAreaHandle( ( PHB_DYNS ) pArea->atomAlias, pArea->uiArea );
}
return pArea;
}
| wacore.c | 559 |
| wafunc.c |
| Type | Function | Source | Line |
|---|
| HB_EXPORT ERRCODE | hb_rddVerifyAliasName( const char * szAlias )
HB_EXPORT ERRCODE hb_rddVerifyAliasName( const char * szAlias )
{
char c;
if( szAlias )
{
/* Clipper ignores only trailing spaces */
#if 0
while( *szAlias == ' ' )
szAlias++;
#endif
c = *szAlias;
if( ( c >= 'A' && c <= 'Z' ) || ( c >= 'a' && c <= 'z' ) || c == '_' )
{
c = *(++szAlias);
while( c != 0 )
{
if( c != '_' && ! ( c >= '0' && c <= '9' ) &&
! ( c >= 'A' && c <= 'Z' ) && ! ( c >= 'a' && c <= 'z' ) )
{
if( c == ' ' )
{
while( *(++szAlias) == ' ' ) { ; }
if( ! *szAlias )
break;
}
return FAILURE;
}
c = *(++szAlias);
}
return SUCCESS;
}
}
return FAILURE;
}
| wafunc.c | 61 |
| HB_EXPORT VOID * | hb_rddNewAreaNode( LPRDDNODE pRddNode, USHORT uiRddID )
HB_EXPORT void * hb_rddNewAreaNode( LPRDDNODE pRddNode, USHORT uiRddID )
{
AREAP pArea;
HB_TRACE(HB_TR_DEBUG, ("hb_rddNewAreaNode(%p,%hu)", pRddNode, uiRddID));
if( pRddNode->uiAreaSize == 0 ) /* Calculate the size of WorkArea */
{
USHORT uiSize;
pArea = ( AREAP ) hb_xgrab( sizeof( AREA ) );
memset( pArea, 0, sizeof( AREA ) );
pArea->lprfsHost = &pRddNode->pTable;
pArea->rddID = uiRddID;
if( SELF_STRUCTSIZE( pArea, &uiSize ) != SUCCESS )
return NULL;
/* Need more space? */
if( uiSize > sizeof( AREA ) ) /* Size of Area changed */
{
pArea = ( AREAP ) hb_xrealloc( pArea, uiSize );
memset( pArea, 0, uiSize );
pArea->lprfsHost = &pRddNode->pTable;
pArea->rddID = uiRddID;
}
pRddNode->uiAreaSize = uiSize; /* Update the size of WorkArea */
}
else
{
pArea = ( AREAP ) hb_xgrab( pRddNode->uiAreaSize );
memset( pArea, 0, pRddNode->uiAreaSize );
pArea->lprfsHost = &pRddNode->pTable;
pArea->rddID = uiRddID;
}
if( SELF_NEW( pArea ) != SUCCESS )
{
SELF_RELEASE( pArea );
return NULL;
}
return ( void * ) pArea;
}
| wafunc.c | 101 |
| HB_EXPORT ERRCODE | hb_rddGetTempAlias( char * szAliasTmp )
HB_EXPORT ERRCODE hb_rddGetTempAlias( char * szAliasTmp )
{
int i, iArea;
for( i = 1; i < 1000; i++ )
{
snprintf( szAliasTmp, 11, "__HBTMP%03i", i);
if( hb_rddGetAliasNumber( szAliasTmp, &iArea ) != SUCCESS )
return SUCCESS;
}
szAliasTmp[0] = '\0';
return FAILURE;
}
| wafunc.c | 150 |
| HB_EXPORT VOID * | hb_rddAllocWorkAreaAlias( const char * szAlias, int iArea )
HB_EXPORT void * hb_rddAllocWorkAreaAlias( const char * szAlias, int iArea )
{
PHB_DYNS pSymAlias;
int iDummyArea;
HB_TRACE(HB_TR_DEBUG, ("hb_rddAllocWorkAreaAlias(%s, %d)", szAlias, iArea));
/* Verify if the alias name is valid symbol */
if( hb_rddVerifyAliasName( szAlias ) != SUCCESS )
{
hb_errRT_DBCMD_Ext( EG_BADALIAS, EDBCMD_BADALIAS, NULL, szAlias, EF_CANDEFAULT );
return NULL;
}
/* Verify if the alias is already in use */
if( hb_rddGetAliasNumber( szAlias, &iDummyArea ) == SUCCESS )
{
hb_errRT_DBCMD_Ext( EG_DUPALIAS, EDBCMD_DUPALIAS, NULL, szAlias, EF_CANDEFAULT );
return NULL;
}
pSymAlias = hb_dynsymGet( szAlias );
if( hb_dynsymAreaHandle( pSymAlias ) != 0 )
{
pSymAlias = NULL;
}
else
{
hb_dynsymSetAreaHandle( pSymAlias, iArea );
}
if( ! pSymAlias )
{
hb_errRT_DBCMD_Ext( EG_DUPALIAS, EDBCMD_DUPALIAS, NULL, szAlias, EF_CANDEFAULT );
}
return pSymAlias;
}
| wafunc.c | 164 |
| HB_EXPORT USHORT | hb_rddFieldIndex( AREAP pArea, const char * szName )
HB_EXPORT USHORT hb_rddFieldIndex( AREAP pArea, const char * szName )
{
USHORT uiCount = 0;
LPFIELD pField;
HB_TRACE(HB_TR_DEBUG, ("hb_rddFieldIndex(%p, %s)", pArea, szName));
while( HB_ISSPACE( *szName ) )
{
++szName;
}
if( *szName )
{
char szSym[ HB_SYMBOL_NAME_LEN + 1 ];
hb_strncpyUpperTrim( szSym, szName, sizeof( szSym ) - 1 );
pField = pArea->lpFields;
while( pField )
{
++uiCount;
if( strcmp( szSym, hb_dynsymName( ( PHB_DYNS ) pField->sym ) ) == 0 )
return uiCount;
pField = pField->lpfNext;
}
}
return 0;
}
| wafunc.c | 205 |
| HB_EXPORT USHORT | hb_rddFieldExpIndex( AREAP pArea, const char * szField )
HB_EXPORT USHORT hb_rddFieldExpIndex( AREAP pArea, const char * szField )
{
int n;
while( HB_ISSPACE( *szField ) )
{
++szField;
}
if( strchr( szField, '>' ) != NULL )
{
char szAlias[ HB_RDD_MAX_ALIAS_LEN + 1 ];
int i, j, l;
n = 0;
if( SELF_ALIAS( pArea, ( BYTE * ) szAlias ) == SUCCESS )
l = strlen( szAlias );
else
l = 0;
/*
* strip the _FIELD-> and FIELD-> prefix, it could be nested
* so repeat this process until all prefixes will be removed
*/
do
{
j = n;
i = 0;
if( HB_ISFIRSTIDCHAR( szField[ n ] ) )
{
++i;
while( HB_ISNEXTIDCHAR( szField[ n + i ] ) )
++i;
if( !( ( i == l &&
hb_strnicmp( &szField[ n ], szAlias, l ) == 0 ) ) &&
!( i >=4 && i <= 5 &&
hb_strnicmp( &szField[ n ], "FIELD", i ) == 0 ) &&
!( i >=4 && i <= 6 &&
hb_strnicmp( &szField[ n ], "_FIELD", i ) == 0 ) )
{
i = 0;
}
}
if( i > 0 )
{
i += n;
while( HB_ISSPACE( szField[ i ] ) )
i++;
if( szField[ i ] == '-' && szField[ i + 1 ] == '>' )
{
n = i + 2;
while( szField[ n ] == ' ' )
n++;
}
}
}
while( n != j );
szField = &szField[ n ];
}
return hb_rddFieldIndex( pArea, szField );
}
| wafunc.c | 237 |
| HB_EXPORT ERRCODE | hb_rddGetAliasNumber( const char * szAlias, int * iArea )
HB_EXPORT ERRCODE hb_rddGetAliasNumber( const char * szAlias, int * iArea )
{
BOOL fOneLetter;
char c;
HB_TRACE(HB_TR_DEBUG, ("hb_rddGetAliasNumber(%s, %p)", szAlias, iArea));
while( *szAlias == ' ' )
{
szAlias++;
}
c = szAlias[ 0 ];
if( c >= 'a' && c <= 'z' )
{
c -= 'a' - 'A';
}
fOneLetter = c && ( szAlias[ 1 ] == 0 || szAlias[ 1 ] == ' ' );
if( c >= '0' && c <= '9' )
{
*iArea = atoi( szAlias );
}
else if( fOneLetter && c >= 'A' && c <= 'K' )
{
*iArea = c - 'A' + 1;
}
else if( fOneLetter && c == 'M' )
{
*iArea = HB_RDD_MAX_AREA_NUM;
}
else
{
PHB_DYNS pSymAlias = hb_dynsymFindName( szAlias );
*iArea = pSymAlias ? ( int ) hb_dynsymAreaHandle( pSymAlias ) : 0;
if( *iArea == 0 )
{
return FAILURE;
}
}
return SUCCESS;
}
| wafunc.c | 305 |
| HB_EXPORT ERRCODE | hb_rddSelectWorkAreaSymbol( PHB_SYMB pSymAlias )
HB_EXPORT ERRCODE hb_rddSelectWorkAreaSymbol( PHB_SYMB pSymAlias )
{
HB_ITEM_PTR pError;
ERRCODE errCode;
const char * szName;
int iArea;
HB_TRACE(HB_TR_DEBUG, ("hb_rddSelectWorkAreaSymbol(%p)", pSymAlias));
iArea = ( int ) hb_dynsymAreaHandle( pSymAlias->pDynSym );
if( iArea )
{
hb_rddSelectWorkAreaNumber( iArea );
return SUCCESS;
}
szName = hb_dynsymName( pSymAlias->pDynSym );
if( szName[ 0 ] && ! szName[ 1 ] )
{
if( szName[ 0 ] >= 'A' && szName[ 0 ] <= 'K' )
{
hb_rddSelectWorkAreaNumber( szName[ 0 ] - 'A' + 1 );
return SUCCESS;
}
else if( szName[ 0 ] >= 'a' && szName[ 0 ] <= 'k' )
{
hb_rddSelectWorkAreaNumber( szName[ 0 ] - 'a' + 1 );
return SUCCESS;
}
else if( szName[ 0 ] == 'M' || szName[ 0 ] == 'm' )
{
hb_rddSelectWorkAreaNumber( HB_RDD_MAX_AREA_NUM );
return SUCCESS;
}
}
/*
* generate an error with retry possibility
* (user created error handler can open a missing database)
*/
pError = hb_errRT_New( ES_ERROR, NULL, EG_NOALIAS, EDBCMD_NOALIAS, NULL, pSymAlias->szName, 0, EF_CANRETRY );
errCode = FAILURE;
do
{
if( hb_errLaunch( pError ) != E_RETRY )
break;
iArea = ( int ) hb_dynsymAreaHandle( pSymAlias->pDynSym );
if( iArea )
{
hb_rddSelectWorkAreaNumber( iArea );
errCode = SUCCESS;
}
}
while( errCode == FAILURE );
hb_itemRelease( pError );
return errCode;
}
| wafunc.c | 353 |
| HB_EXPORT ERRCODE | hb_rddSelectWorkAreaAlias( const char * szAlias )
HB_EXPORT ERRCODE hb_rddSelectWorkAreaAlias( const char * szAlias )
{
ERRCODE errCode;
int iArea;
HB_TRACE(HB_TR_DEBUG, ("hb_rddSelectWorkAreaAlias(%s)", szAlias));
errCode = hb_rddGetAliasNumber( szAlias, &iArea );
if( errCode == FAILURE )
{
/*
* generate an error with retry possibility
* (user created error handler can open a missing database)
*/
HB_ITEM_PTR pError = hb_errRT_New( ES_ERROR, NULL, EG_NOALIAS, EDBCMD_NOALIAS, NULL, szAlias, 0, EF_CANRETRY );
do
{
if( hb_errLaunch( pError ) != E_RETRY )
break;
errCode = hb_rddGetAliasNumber( szAlias, &iArea );
}
while( errCode == FAILURE );
hb_itemRelease( pError );
}
if( errCode == SUCCESS )
{
if( iArea < 1 || iArea > HB_RDD_MAX_AREA_NUM )
errCode = hb_rddSelectFirstAvailable();
else
errCode = hb_rddSelectWorkAreaNumber( iArea );
}
return errCode;
}
| wafunc.c | 419 |
| HB_EXPORT ERRCODE | hb_rddFieldGet( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol )
HB_EXPORT ERRCODE hb_rddFieldGet( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol )
{
AREAP pArea;
HB_TRACE(HB_TR_DEBUG, ("hb_rddFieldGet(%p, %p)", pItem, pFieldSymbol));
pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
USHORT uiField = 1;
LPFIELD pField = pArea->lpFields;
PHB_DYNS pDynSym = pFieldSymbol->pDynSym;
while( pField )
{
if( ( PHB_DYNS ) pField->sym == pDynSym )
{
return SELF_GETVALUE( pArea, uiField, pItem );
}
++uiField;
pField = pField->lpfNext;
}
}
return FAILURE;
}
| wafunc.c | 461 |
| HB_EXPORT ERRCODE | hb_rddFieldPut( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol )
HB_EXPORT ERRCODE hb_rddFieldPut( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol )
{
AREAP pArea;
HB_TRACE(HB_TR_DEBUG, ("hb_rddFieldPut(%p, %p)", pItem, pFieldSymbol));
pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
USHORT uiField = 1;
LPFIELD pField = pArea->lpFields;
PHB_DYNS pDynSym = pFieldSymbol->pDynSym;
while( pField )
{
if( ( PHB_DYNS ) pField->sym == pDynSym )
{
return SELF_PUTVALUE( pArea, uiField, pItem );
}
++uiField;
pField = pField->lpfNext;
}
}
return FAILURE;
}
| wafunc.c | 490 |
| HB_EXPORT ERRCODE | hb_rddGetFieldValue( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol )
HB_EXPORT ERRCODE hb_rddGetFieldValue( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol )
{
ERRCODE errCode;
HB_TRACE(HB_TR_DEBUG, ("hb_rddGetFieldValue(%p, %p)", pItem, pFieldSymbol));
errCode = hb_rddFieldGet( pItem, pFieldSymbol );
if( errCode == FAILURE && hb_vmRequestQuery() == 0 )
{
/*
* generate an error with retry possibility
* (user created error handler can make this field accessible)
*/
PHB_ITEM pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, EDBCMD_NOVAR,
NULL, pFieldSymbol->szName, 0, EF_CANRETRY );
while( hb_errLaunch( pError ) == E_RETRY )
{
errCode = hb_rddFieldGet( pItem, pFieldSymbol );
if( errCode == SUCCESS || hb_vmRequestQuery() != 0 )
break;
}
hb_itemRelease( pError );
}
return errCode;
}
| wafunc.c | 519 |
| HB_EXPORT ERRCODE | hb_rddPutFieldValue( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol )
HB_EXPORT ERRCODE hb_rddPutFieldValue( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol )
{
ERRCODE errCode;
HB_TRACE(HB_TR_DEBUG, ("hb_rddPutFieldValue(%p, %p)", pItem, pFieldSymbol));
errCode = hb_rddFieldPut( pItem, pFieldSymbol );
if( errCode == FAILURE && hb_vmRequestQuery() == 0 )
{
/*
* generate an error with retry possibility
* (user created error handler can make this field accessible)
*/
PHB_ITEM pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, EDBCMD_NOVAR,
NULL, pFieldSymbol->szName, 0, EF_CANRETRY );
while( hb_errLaunch( pError ) == E_RETRY )
{
errCode = hb_rddFieldPut( pItem, pFieldSymbol );
if( errCode == SUCCESS || hb_vmRequestQuery() != 0 )
break;
}
hb_itemRelease( pError );
}
return errCode;
}
| wafunc.c | 552 |
| ERRCODE | hb_rddOpenTable( const char * szFileName, const char * szDriver, USHORT uiArea, const char *szAlias, BOOL fShared, BOOL fReadonly, const char * szCpId, ULONG ulConnection, PHB_ITEM pStruct, PHB_ITEM pDelim )
ERRCODE hb_rddOpenTable( const char * szFileName, const char * szDriver,
USHORT uiArea, const char *szAlias,
BOOL fShared, BOOL fReadonly,
const char * szCpId, ULONG ulConnection,
PHB_ITEM pStruct, PHB_ITEM pDelim )
{
char szDriverBuffer[ HB_RDD_MAX_DRIVERNAME_LEN + 1 ];
DBOPENINFO pInfo;
ERRCODE errCode;
AREAP pArea;
/* uiArea = 0 in hb_rddInsertAreaNode() means chose first
* available free area, otherwise we should close table in
* current WA and it should be done before parameter validation
* RT errors below. This breaks xHarbour like MT code which
* shares WA between threads so dbUseArea() should be covered
* by external mutex to make lNewArea MT safe, [druzus]
*/
if( uiArea )
{
hb_rddSelectWorkAreaNumber( uiArea );
hb_rddReleaseCurrentArea();
}
else
hb_rddSelectFirstAvailable();
/* Clipper clears NETERR flag before parameter validation, [druzus]
*/
hb_rddSetNetErr( FALSE );
/* Now check parameters, first RDD name.
* Clipper seems to make sth like:
* if( szDriver && strlen( szDriver ) > 1 )
* but I do not think we should replicate it, [druzus]
*/
if( szDriver && szDriver[ 0 ] )
{
hb_strncpyUpper( szDriverBuffer, szDriver, sizeof( szDriverBuffer ) - 1 );
szDriver = szDriverBuffer;
}
else
szDriver = hb_rddDefaultDrv( NULL );
/* First try to create new are node and validate RDD name */
if( ! hb_rddInsertAreaNode( szDriver ) )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return FAILURE;
}
/* Then check if valid file name was given - Clipper allows to use empty
* ("") file name
*/
if( !szFileName )
{
hb_rddReleaseCurrentArea();
hb_errRT_DBCMD( EG_ARG, EDBCMD_USE_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return FAILURE;
}
pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
/* Fill pInfo structure */
pInfo.uiArea = pArea->uiArea;
pInfo.abName = ( BYTE * ) szFileName;
pInfo.atomAlias = ( BYTE * ) szAlias;
pInfo.fShared = fShared;
pInfo.fReadonly = fReadonly;
pInfo.cdpId = ( BYTE * ) szCpId;
pInfo.ulConnection = ulConnection;
pInfo.lpdbHeader = NULL;
errCode = pStruct ? SELF_CREATEFIELDS( pArea, pStruct ) : SUCCESS;
if( errCode == SUCCESS )
{
if( pDelim && !HB_IS_NIL( pDelim ) )
errCode = SELF_INFO( pArea, DBI_SETDELIMITER, pDelim );
if( errCode == SUCCESS )
/* Open file */
errCode = SELF_OPEN( pArea, &pInfo );
}
if( errCode != SUCCESS )
hb_rddReleaseCurrentArea();
return errCode;
}
| wafunc.c | 585 |
| ERRCODE | hb_rddCreateTable( const char * szFileName, const char * szDriver, USHORT uiArea, const char *szAlias, BOOL fKeepOpen, const char * szCpId, ULONG ulConnection, PHB_ITEM pStruct, PHB_ITEM pDelim )
ERRCODE hb_rddCreateTable( const char * szFileName, const char * szDriver,
USHORT uiArea, const char *szAlias,
BOOL fKeepOpen,
const char * szCpId, ULONG ulConnection,
PHB_ITEM pStruct, PHB_ITEM pDelim )
{
char szDriverBuffer[ HB_RDD_MAX_DRIVERNAME_LEN + 1 ];
DBOPENINFO pInfo;
ERRCODE errCode;
USHORT uiPrevArea;
AREAP pArea;
if( !szFileName )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBCMDBADPARAMETER, NULL, HB_ERR_FUNCNAME );
return FAILURE;
}
if( szDriver && szDriver[ 0 ] )
{
hb_strncpyUpper( szDriverBuffer, szDriver, sizeof( szDriverBuffer ) - 1 );
szDriver = szDriverBuffer;
}
else
szDriver = hb_rddDefaultDrv( NULL );
uiPrevArea = hb_rddGetCurrentWorkAreaNumber();
/*
* 0 means chose first available in hb_rddInsertAreaNode()
* This hack is necessary to avoid race condition in MT
* mode where workareas are shared between threads and
* we don't want to lock whole RDD subsystem, [druzus]
*/
hb_rddSelectWorkAreaNumber( uiArea );
if( uiArea )
hb_rddReleaseCurrentArea();
/* Create a new WorkArea node */
if( ! hb_rddInsertAreaNode( szDriver ) )
{
hb_rddSelectWorkAreaNumber( uiPrevArea );
hb_errRT_DBCMD( EG_ARG, EDBCMD_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return FAILURE;
}
pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
/* Fill pInfo structure */
pInfo.uiArea = pArea->uiArea;
pInfo.abName = ( BYTE * ) szFileName;
pInfo.atomAlias = ( BYTE * ) szAlias;
pInfo.fShared = FALSE;
pInfo.fReadonly = FALSE;
pInfo.cdpId = ( BYTE * ) szCpId;
pInfo.ulConnection = ulConnection;
pInfo.lpdbHeader = NULL;
if( pDelim && !HB_IS_NIL( pDelim ) )
errCode = SELF_INFO( pArea, DBI_SETDELIMITER, pDelim );
else
errCode = SUCCESS;
if( errCode == SUCCESS )
{
errCode = SELF_CREATEFIELDS( pArea, pStruct );
if( errCode == SUCCESS )
errCode = SELF_CREATE( pArea, &pInfo );
}
if( !fKeepOpen || errCode != SUCCESS )
{
hb_rddReleaseCurrentArea();
hb_rddSelectWorkAreaNumber( uiPrevArea );
}
return errCode;
}
| wafunc.c | 673 |
| STATIC VOID | hb_fldStructure( AREAP pArea, USHORT uiField, USHORT uiSize, PHB_ITEM pField )
static void hb_fldStructure( AREAP pArea, USHORT uiField, USHORT uiSize,
PHB_ITEM pField )
{
#define HB_DBS_ALEN ( sizeof( s_uiActions ) / sizeof( int ) )
#ifdef DBS_FLAG
static const int s_uiActions[] =
{ DBS_NAME, DBS_TYPE, DBS_LEN, DBS_DEC, DBS_FLAG };
#else
static const int s_uiActions[] =
{ DBS_NAME, DBS_TYPE, DBS_LEN, DBS_DEC };
#endif
USHORT uiCount;
if( uiSize == 0 || uiSize > HB_DBS_ALEN )
uiSize = HB_DBS_ALEN;
hb_arrayNew( pField, uiSize );
for( uiCount = 0; uiCount < uiSize; ++uiCount )
{
SELF_FIELDINFO( pArea, uiField, s_uiActions[uiCount],
hb_arrayGetItemPtr( pField, uiCount + 1 ) );
}
}
| wafunc.c | 751 |
| VOID | hb_tblStructure( AREAP pArea, PHB_ITEM pStruct, USHORT uiSize )
void hb_tblStructure( AREAP pArea, PHB_ITEM pStruct, USHORT uiSize )
{
USHORT uiFields, uiCount;
if( SELF_FIELDCOUNT( pArea, &uiFields ) == SUCCESS )
{
if( hb_arraySize( pStruct, uiFields ) )
{
for( uiCount = 1; uiCount <= uiFields; ++uiCount )
hb_fldStructure( pArea, uiCount, uiSize,
hb_arrayGetItemPtr( pStruct, uiCount ) );
}
}
}
| wafunc.c | 775 |
| STATIC CHAR * | hb_dbTransFieldPos( PHB_ITEM pFields, USHORT uiField )
static char * hb_dbTransFieldPos( PHB_ITEM pFields, USHORT uiField )
{
char * szField = NULL;
PHB_ITEM pItem;
pItem = hb_arrayGetItemPtr( pFields, uiField );
if( pItem )
{
HB_TYPE type = hb_itemType( pItem );
if( type & HB_IT_ARRAY )
szField = hb_arrayGetCPtr( pItem, DBS_NAME );
else if( type & HB_IT_STRING )
szField = hb_itemGetCPtr( pItem );
if( * szField == '\0' )
szField = NULL;
}
return szField;
}
| wafunc.c | 790 |
| ERRCODE | hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest, LPDBTRANSINFO lpdbTransInfo, PHB_ITEM *pStruct, PHB_ITEM pFields )
ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
LPDBTRANSINFO lpdbTransInfo,
PHB_ITEM *pStruct, PHB_ITEM pFields )
{
USHORT uiFields, uiSize, uiCount, uiPosSrc, uiPosDst, uiSizeSrc, uiSizeDst;
ERRCODE errCode;
char * szField;
BOOL fAll;
errCode = SELF_FIELDCOUNT( lpaSource, &uiSizeSrc );
if( errCode != SUCCESS )
return errCode;
if( lpaDest )
{
errCode = SELF_FIELDCOUNT( lpaDest, &uiSizeDst );
if( errCode != SUCCESS )
return errCode;
uiSize = HB_MIN( uiSizeDst, uiSizeSrc );
}
else
{
uiSize = uiSizeDst = uiSizeSrc;
}
if( !uiSize )
return FAILURE;
if( hb_itemType( pFields ) & HB_IT_ARRAY )
{
uiFields = ( USHORT ) hb_arrayLen( pFields );
if( uiFields )
uiSize = uiFields;
}
else
uiFields = 0;
fAll = ( uiSizeDst == uiSizeSrc );
lpdbTransInfo->lpaSource = lpaSource;
lpdbTransInfo->lpaDest = lpaDest;
lpdbTransInfo->lpTransItems = ( LPDBTRANSITEM )
hb_xgrab( uiSize * sizeof( DBTRANSITEM ) );
if( !lpaDest )
{
*pStruct = hb_itemNew( NULL );
hb_arrayNew( *pStruct, 0 );
}
if( uiFields == 0 )
{
if( lpaDest )
{
PHB_ITEM pItem = hb_itemNew( NULL );
uiSize = 0;
for( uiCount = 1; uiCount <= uiSizeSrc; ++uiCount )
{
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_NAME, pItem ) != SUCCESS )
{
uiSize = 0;
break;
}
szField = hb_itemGetCPtr( pItem );
uiPosDst = hb_rddFieldExpIndex( lpaDest, szField );
if( uiPosDst != uiCount )
fAll = FALSE;
if( uiPosDst )
{
USHORT ui;
/* check for replicated field names in source area */
for( ui = 0; ui < uiSize; ++ui )
{
if( lpdbTransInfo->lpTransItems[ ui ].uiDest == uiPosDst )
break;
}
if( ui == uiSize )
{
lpdbTransInfo->lpTransItems[ uiSize ].uiSource = uiCount;
lpdbTransInfo->lpTransItems[ uiSize++ ].uiDest = uiPosDst;
}
}
}
hb_itemRelease( pItem );
}
else
{
hb_tblStructure( lpaSource, *pStruct, 0 );
uiSize = ( USHORT ) hb_arrayLen( *pStruct );
for( uiCount = 0; uiCount < uiSize; ++uiCount )
{
lpdbTransInfo->lpTransItems[ uiCount ].uiSource =
lpdbTransInfo->lpTransItems[ uiCount ].uiDest = uiCount + 1;
}
}
}
else
{
uiSize = 0;
for( uiCount = 1; uiCount <= uiFields; ++uiCount )
{
szField = hb_dbTransFieldPos( pFields, uiCount );
if( szField )
{
uiPosSrc = hb_rddFieldExpIndex( lpaSource, szField );
if( !uiPosSrc )
continue;
if( lpaDest )
uiPosDst = hb_rddFieldExpIndex( lpaDest, szField );
else
uiPosDst = uiSize + 1;
if( uiPosDst )
{
if( uiPosSrc != uiPosDst )
fAll = FALSE;
lpdbTransInfo->lpTransItems[ uiSize ].uiSource = uiPosSrc;
lpdbTransInfo->lpTransItems[ uiSize++ ].uiDest = uiPosDst;
if( !lpaDest )
{
hb_arraySize( *pStruct, uiSize );
hb_fldStructure( lpaSource, uiPosSrc, 0,
hb_arrayGetItemPtr( *pStruct, uiSize ) );
}
}
}
}
}
if( uiSize != uiSizeSrc )
fAll = FALSE;
if( fAll && lpaDest )
{
PHB_ITEM pSrcItm = hb_itemNew( NULL ),
pDstItm = hb_itemNew( NULL );
/*
* if fAll is TRUE here then it means that all fields are included
* and they are on the same positions in both tables, so now check
* if their types and sizes are also equal
*/
for( uiCount = 1; uiCount <= uiSize; ++uiCount )
{
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_TYPE, pSrcItm ) != SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_TYPE, pDstItm ) != SUCCESS )
{
uiSize = 0;
break;
}
if( hb_stricmp( hb_itemGetCPtr( pSrcItm ),
hb_itemGetCPtr( pDstItm ) ) != 0 )
{
fAll = FALSE;
break;
}
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_LEN, pSrcItm ) != SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_LEN, pDstItm ) != SUCCESS )
{
uiSize = 0;
break;
}
if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
{
fAll = FALSE;
break;
}
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_DEC, pSrcItm ) != SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_DEC, pDstItm ) != SUCCESS )
{
uiSize = 0;
break;
}
if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
{
fAll = FALSE;
break;
}
#ifdef DBS_FLAG
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_FLAG, pSrcItm ) != SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_FLAG, pDstItm ) != SUCCESS )
{
uiSize = 0;
break;
}
#endif
if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
{
fAll = FALSE;
break;
}
}
hb_itemRelease( pSrcItm );
hb_itemRelease( pDstItm );
}
lpdbTransInfo->uiFlags = fAll ? DBTF_MATCH : 0;
lpdbTransInfo->uiItemCount = uiSize;
return uiSize ? SUCCESS : FAILURE;
}
| wafunc.c | 812 |
| ERRCODE | hb_rddTransRecords( AREAP pArea, const char *szFileName, const char *szDriver, ULONG ulConnection, PHB_ITEM pFields, BOOL fExport, PHB_ITEM pCobFor, PHB_ITEM pStrFor, PHB_ITEM pCobWhile, PHB_ITEM pStrWhile, PHB_ITEM pNext, PHB_ITEM pRecID, PHB_ITEM pRest, const char *szCpId, PHB_ITEM pDelim )
ERRCODE hb_rddTransRecords( AREAP pArea,
const char *szFileName, const char *szDriver,
ULONG ulConnection,
PHB_ITEM pFields, BOOL fExport,
PHB_ITEM pCobFor, PHB_ITEM pStrFor,
PHB_ITEM pCobWhile, PHB_ITEM pStrWhile,
PHB_ITEM pNext, PHB_ITEM pRecID,
PHB_ITEM pRest,
const char *szCpId,
PHB_ITEM pDelim )
{
AREAP lpaClose = NULL;
PHB_ITEM pStruct = NULL;
DBTRANSINFO dbTransInfo;
USHORT uiPrevArea, uiCount, uiSwap;
ERRCODE errCode;
memset( &dbTransInfo, 0, sizeof( DBTRANSINFO ) );
uiPrevArea = hb_rddGetCurrentWorkAreaNumber();
if( szDriver == NULL )
/* szDriver = SELF_RDDNODE( pArea )->szName; */
szDriver = hb_rddDefaultDrv( NULL );
if( fExport )
{
errCode = hb_dbTransStruct( pArea, NULL, &dbTransInfo,
&pStruct, pFields );
if( errCode == SUCCESS )
{
errCode = hb_rddCreateTable( szFileName, szDriver, 0, "",
TRUE,
szCpId, ulConnection, pStruct, pDelim );
if( errCode == SUCCESS )
{
dbTransInfo.lpaDest = lpaClose =
( AREAP ) hb_rddGetCurrentWorkAreaPointer();
}
}
}
else
{
LPRDDNODE pRddNode = hb_rddFindNode( szDriver, NULL );
if( !pRddNode )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_USE_BADPARAMETER, NULL, HB_ERR_FUNCNAME );
return FAILURE;
}
if( pRddNode->uiType == RDT_TRANSFER )
{
errCode = hb_dbTransStruct( pArea, NULL, &dbTransInfo,
&pStruct, pFields );
/* revert area and items */
dbTransInfo.lpaDest = dbTransInfo.lpaSource;
for( uiCount = 0; uiCount < dbTransInfo.uiItemCount; ++uiCount )
{
uiSwap = dbTransInfo.lpTransItems[uiCount].uiSource;
dbTransInfo.lpTransItems[uiCount].uiSource =
dbTransInfo.lpTransItems[uiCount].uiDest;
dbTransInfo.lpTransItems[uiCount].uiDest = uiSwap;
}
if( errCode == SUCCESS )
{
errCode = hb_rddOpenTable( szFileName, szDriver, 0, "", TRUE, TRUE,
szCpId, ulConnection, pStruct, pDelim );
if( errCode == SUCCESS )
{
lpaClose = dbTransInfo.lpaSource =
( AREAP ) hb_rddGetCurrentWorkAreaPointer();
}
}
}
else
{
errCode = hb_rddOpenTable( szFileName, szDriver, 0, "", TRUE, TRUE,
szCpId, ulConnection, NULL, pDelim );
if( errCode == SUCCESS )
{
lpaClose = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
errCode = hb_dbTransStruct( lpaClose, pArea, &dbTransInfo,
NULL, pFields );
}
}
}
if( pStruct )
hb_itemRelease( pStruct );
if( errCode == SUCCESS )
{
hb_rddSelectWorkAreaNumber( dbTransInfo.lpaSource->uiArea );
dbTransInfo.dbsci.itmCobFor = pCobFor;
dbTransInfo.dbsci.lpstrFor = pStrFor;
dbTransInfo.dbsci.itmCobWhile = pCobWhile;
dbTransInfo.dbsci.lpstrWhile = pStrWhile;
dbTransInfo.dbsci.lNext = pNext;
dbTransInfo.dbsci.itmRecID = pRecID;
dbTransInfo.dbsci.fRest = pRest;
dbTransInfo.dbsci.fIgnoreFilter = TRUE;
dbTransInfo.dbsci.fIncludeDeleted = TRUE;
dbTransInfo.dbsci.fLast = FALSE;
dbTransInfo.dbsci.fIgnoreDuplicates = FALSE;
dbTransInfo.dbsci.fBackward = FALSE;
errCode = SELF_TRANS( dbTransInfo.lpaSource, &dbTransInfo );
}
if( dbTransInfo.lpTransItems )
hb_xfree( dbTransInfo.lpTransItems );
if( lpaClose )
{
hb_rddSelectWorkAreaNumber( lpaClose->uiArea );
hb_rddReleaseCurrentArea();
}
hb_rddSelectWorkAreaNumber( uiPrevArea );
return errCode;
}
| wafunc.c | 1012 |
| STATIC ERRCODE | hb_rddCloseParentRel( AREAP pArea, void * pChildArea )
static ERRCODE hb_rddCloseParentRel( AREAP pArea, void * pChildArea )
{
if( pArea->lpdbRelations )
{
LPDBRELINFO * lpdbRelationPtr = &pArea->lpdbRelations;
USHORT uiArea = ( ( AREAP ) pChildArea )->uiArea;
do
{
LPDBRELINFO lpdbRelation = *lpdbRelationPtr;
if( lpdbRelation->lpaChild->uiArea == uiArea )
{
/* Clear this relation */
hb_rddSelectWorkAreaNumber( lpdbRelation->lpaChild->uiArea );
SELF_CHILDEND( lpdbRelation->lpaChild, lpdbRelation );
if( lpdbRelation->itmCobExpr )
hb_itemRelease( lpdbRelation->itmCobExpr );
if( lpdbRelation->abKey )
hb_itemRelease( lpdbRelation->abKey );
*lpdbRelationPtr = lpdbRelation->lpdbriNext;
hb_xfree( lpdbRelation );
}
else
lpdbRelationPtr = &lpdbRelation->lpdbriNext;
}
while ( *lpdbRelationPtr );
}
return SUCCESS;
}
| wafunc.c | 1137 |
| ERRCODE | hb_rddCloseAllParentRelations( AREAP pArea )
ERRCODE hb_rddCloseAllParentRelations( AREAP pArea )
{
ERRCODE errCode = SUCCESS;
HB_TRACE(HB_TR_DEBUG, ("hb_rddCloseAllParentRelations(%p)", pArea));
if( pArea->uiParents > 0 )
errCode = hb_rddIterateWorkAreas( hb_rddCloseParentRel, pArea );
return errCode;
}
| wafunc.c | 1169 |
| workarea.c |
| Type | Function | Source | Line |
|---|
| STATIC ERRCODE | hb_waBof( AREAP pArea, BOOL * pBof )
static ERRCODE hb_waBof( AREAP pArea, BOOL * pBof )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waBof(%p, %p)", pArea, pBof));
* pBof = pArea->fBof;
return SUCCESS;
}
| workarea.c | 74 |
| STATIC ERRCODE | hb_waEof( AREAP pArea, BOOL * pEof )
static ERRCODE hb_waEof( AREAP pArea, BOOL * pEof )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waEof(%p, %p)", pArea, pEof));
* pEof = pArea->fEof;
return SUCCESS;
}
| workarea.c | 85 |
| STATIC ERRCODE | hb_waFound( AREAP pArea, BOOL * pFound )
static ERRCODE hb_waFound( AREAP pArea, BOOL * pFound )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waFound(%p, %p)", pArea, pFound));
* pFound = pArea->fFound;
return SUCCESS;
}
| workarea.c | 96 |
| STATIC ERRCODE | hb_waSkip( AREAP pArea, LONG lToSkip )
static ERRCODE hb_waSkip( AREAP pArea, LONG lToSkip )
{
LONG lSkip;
HB_TRACE(HB_TR_DEBUG, ("hb_waSkip(%p, %ld)", pArea, lToSkip));
/* Flush record and exit */
if( lToSkip == 0 )
return SELF_SKIPRAW( pArea, 0 );
pArea->fTop = pArea->fBottom = FALSE;
if( lToSkip > 0 )
lSkip = 1;
else
{
lSkip = -1;
lToSkip *= -1;
}
while( --lToSkip >= 0 )
{
if( SELF_SKIPRAW( pArea, lSkip ) != SUCCESS )
return FAILURE;
if( SELF_SKIPFILTER( pArea, lSkip ) != SUCCESS )
return FAILURE;
if( pArea->fBof || pArea->fEof )
break;
}
/* Update Bof and Eof flags */
if( lSkip < 0 )
pArea->fEof = FALSE;
else /* ( lSkip > 0 ) */
pArea->fBof = FALSE;
return SUCCESS;
}
| workarea.c | 107 |
| STATIC ERRCODE | hb_waSkipFilter( AREAP pArea, LONG lUpDown )
static ERRCODE hb_waSkipFilter( AREAP pArea, LONG lUpDown )
{
BOOL fBottom, fDeleted;
ERRCODE uiError;
HB_TRACE(HB_TR_DEBUG, ("hb_waSkipFilter(%p, %ld)", pArea, lUpDown));
if( pArea->dbfi.itmCobExpr == NULL && !hb_setGetDeleted() )
return SUCCESS;
/* Since lToSkip is passed to SkipRaw, it should never request more than
a single skip.
The implied purpose of hb_waSkipFilter is to get off of a "bad" record
after a skip was performed, NOT to skip lToSkip filtered records.
*/
lUpDown = ( lUpDown < 0 ? -1 : 1 );
/* remember if we are here after SLEF_GOTOP() */
fBottom = pArea->fBottom;
while( !pArea->fBof && !pArea->fEof )
{
/* SET DELETED */
if( hb_setGetDeleted() )
{
if( SELF_DELETED( pArea, &fDeleted ) != SUCCESS )
return FAILURE;
if( fDeleted )
{
if( SELF_SKIPRAW( pArea, lUpDown ) != SUCCESS )
return FAILURE;
continue;
}
}
/* SET FILTER TO */
if( pArea->dbfi.itmCobExpr )
{
if( SELF_EVALBLOCK( pArea, pArea->dbfi.itmCobExpr ) != SUCCESS )
return FAILURE;
if( HB_IS_LOGICAL( pArea->valResult ) &&
!hb_itemGetL( pArea->valResult ) )
{
if( SELF_SKIPRAW( pArea, lUpDown ) != SUCCESS )
return FAILURE;
continue;
}
}
break;
}
/*
* The only one situation when we should repos is backward skipping
* if we are at BOTTOM position (it's SKIPFILTER called from GOBOTTOM)
* then GOEOF() if not then GOTOP()
*/
if( pArea->fBof && lUpDown < 0 )
{
if( fBottom )
{
/* GOTO EOF (phantom) record -
this is the only one place where GOTO is used by xHarbour
directly and RDD which does not operate on numbers should
serve this method only as SELF_GOEOF() synonym. If it's a
problem then we can remove this if and always use SELF_GOTOP()
but it also means second table scan if all records filtered
are out of filter so I do not want to do that. I will prefer
explicit add SELF_GOEOF() method
*/
uiError = SELF_GOTO( pArea, 0 );
}
else
{
uiError = SELF_GOTOP( pArea );
pArea->fBof = TRUE;
}
}
else
{
uiError = SUCCESS;
}
return uiError;
}
| workarea.c | 148 |
| STATIC ERRCODE | hb_waAddField( AREAP pArea, LPDBFIELDINFO pFieldInfo )
static ERRCODE hb_waAddField( AREAP pArea, LPDBFIELDINFO pFieldInfo )
{
LPFIELD pField;
char szFieldName[ HB_SYMBOL_NAME_LEN + 1 ], *szPtr;
HB_TRACE(HB_TR_DEBUG, ("hb_waAddField(%p, %p)", pArea, pFieldInfo));
/* Validate the name of field */
szPtr = ( char * ) pFieldInfo->atomName;
while( HB_ISSPACE( *szPtr ) )
{
++szPtr;
}
hb_strncpyUpperTrim( szFieldName, szPtr, sizeof( szFieldName ) - 1 );
if( strlen( szFieldName ) == 0 )
return FAILURE;
pField = pArea->lpFields + pArea->uiFieldCount;
if( pArea->uiFieldCount > 0 )
( ( LPFIELD ) ( pField - 1 ) )->lpfNext = pField;
pField->sym = ( void * ) hb_dynsymGetCase( szFieldName );
pField->uiType = pFieldInfo->uiType;
pField->uiTypeExtended = pFieldInfo->uiTypeExtended;
pField->uiLen = pFieldInfo->uiLen;
pField->uiDec = pFieldInfo->uiDec;
pField->uiFlags = pFieldInfo->uiFlags;
pField->uiArea = pArea->uiArea;
pArea->uiFieldCount ++;
return SUCCESS;
}
| workarea.c | 238 |
| STATIC ERRCODE | hb_waCreateFields( AREAP pArea, PHB_ITEM pStruct )
static ERRCODE hb_waCreateFields( AREAP pArea, PHB_ITEM pStruct )
{
USHORT uiItems, uiCount, uiLen, uiDec;
ERRCODE errCode = SUCCESS;
DBFIELDINFO pFieldInfo;
PHB_ITEM pFieldDesc;
int iData;
HB_TRACE(HB_TR_DEBUG, ("hb_waCreateFields(%p, %p)", pArea, pStruct));
uiItems = ( USHORT ) hb_arrayLen( pStruct );
if( SELF_SETFIELDEXTENT( pArea, uiItems ) != SUCCESS )
return FAILURE;
for( uiCount = 0; uiCount < uiItems; uiCount++ )
{
pFieldInfo.uiTypeExtended = 0;
pFieldDesc = hb_arrayGetItemPtr( pStruct, uiCount + 1 );
pFieldInfo.atomName = ( BYTE * ) hb_arrayGetCPtr( pFieldDesc, DBS_NAME );
iData = hb_arrayGetNI( pFieldDesc, DBS_LEN );
if( iData < 0 )
iData = 0;
uiLen = pFieldInfo.uiLen = ( USHORT ) iData;
iData = hb_arrayGetNI( pFieldDesc, DBS_DEC );
if( iData < 0 )
iData = 0;
uiDec = ( USHORT ) iData;
pFieldInfo.uiDec = 0;
#ifdef DBS_FLAG
pFieldInfo.uiFlags = hb_arrayGetNI( pFieldDesc, DBS_FLAG );
#else
pFieldInfo.uiFlags = 0;
#endif
iData = toupper( hb_arrayGetCPtr( pFieldDesc, DBS_TYPE )[ 0 ] );
switch( iData )
{
case 'C':
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = uiLen;
/* Too many people reported the behavior with code below as a
Clipper compatibility bug so I commented this code. Druzus.
#ifdef HB_C52_STRICT
pFieldInfo.uiLen = uiLen;
#else
pFieldInfo.uiLen = uiLen + uiDec * 256;
#endif
*/
break;
case 'L':
pFieldInfo.uiType = HB_FT_LOGICAL;
pFieldInfo.uiLen = 1;
break;
case 'D':
pFieldInfo.uiType = HB_FT_DATE;
pFieldInfo.uiLen = ( uiLen == 3 || uiLen == 4 ) ? uiLen : 8;
break;
case 'I':
pFieldInfo.uiType = HB_FT_INTEGER;
pFieldInfo.uiLen = ( ( uiLen > 0 && uiLen <= 4 ) || uiLen == 8 ) ? uiLen : 4;
pFieldInfo.uiDec = uiDec;
break;
case 'Y':
pFieldInfo.uiType = HB_FT_CURRENCY;
pFieldInfo.uiLen = 8;
pFieldInfo.uiDec = 4;
break;
case 'Z':
pFieldInfo.uiType = HB_FT_CURDOUBLE;
pFieldInfo.uiLen = 8;
pFieldInfo.uiDec = uiDec;
break;
case '2':
case '4':
pFieldInfo.uiType = HB_FT_INTEGER;
pFieldInfo.uiLen = iData - '0';
break;
case 'B':
case '8':
pFieldInfo.uiType = HB_FT_DOUBLE;
pFieldInfo.uiLen = 8;
pFieldInfo.uiDec = uiDec;
break;
case 'N':
pFieldInfo.uiType = HB_FT_LONG;
pFieldInfo.uiDec = uiDec;
/* DBASE documentation defines maximum numeric field size as 20
* but Clipper alows to create longer fileds so I remove this
* limit, Druzus
*/
/*
if( uiLen > 20 )
*/
if( uiLen > 255 )
errCode = FAILURE;
break;
case 'F':
pFieldInfo.uiType = HB_FT_FLOAT;
pFieldInfo.uiDec = uiDec;
/* see note above */
if( uiLen > 255 )
errCode = FAILURE;
break;
case 'T':
if( uiLen == 8 )
{
pFieldInfo.uiType = HB_FT_DAYTIME;
pFieldInfo.uiLen = 8;
}
else
{
pFieldInfo.uiType = HB_FT_TIME;
pFieldInfo.uiLen = 4;
}
break;
case '@':
pFieldInfo.uiType = HB_FT_DAYTIME;
pFieldInfo.uiLen = 8;
break;
case '=':
pFieldInfo.uiType = HB_FT_MODTIME;
pFieldInfo.uiLen = 8;
break;
case '^':
pFieldInfo.uiType = HB_FT_ROWVER;
pFieldInfo.uiLen = 8;
break;
case '+':
pFieldInfo.uiType = HB_FT_AUTOINC;
pFieldInfo.uiLen = 4;
break;
case 'Q':
pFieldInfo.uiType = HB_FT_VARLENGTH;
pFieldInfo.uiLen = uiLen > 255 ? 255 : uiLen;
break;
case 'M':
pFieldInfo.uiType = HB_FT_MEMO;
pFieldInfo.uiLen = ( uiLen == 4 ) ? 4 : 10;
break;
case 'V':
pFieldInfo.uiType = HB_FT_ANY;
pFieldInfo.uiLen = ( uiLen < 3 || uiLen == 5 ) ? 6 : uiLen;
break;
case 'P':
pFieldInfo.uiType = HB_FT_IMAGE;
pFieldInfo.uiLen = ( uiLen == 4 ) ? 4 : 10;
break;
case 'W':
pFieldInfo.uiType = HB_FT_BLOB;
pFieldInfo.uiLen = ( uiLen == 4 ) ? 4 : 10;
break;
case 'G':
pFieldInfo.uiType = HB_FT_OLE;
pFieldInfo.uiLen = ( uiLen == 4 ) ? 4 : 10;
break;
default:
errCode = FAILURE;
break;
}
if( errCode != SUCCESS )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBCMDBADPARAMETER, NULL, HB_ERR_FUNCNAME );
return errCode;
}
/* Add field */
else if( SELF_ADDFIELD( pArea, &pFieldInfo ) != SUCCESS )
return FAILURE;
}
return SUCCESS;
}
| workarea.c | 272 |
| STATIC ERRCODE | hb_waFieldCount( AREAP pArea, USHORT * uiFields )
static ERRCODE hb_waFieldCount( AREAP pArea, USHORT * uiFields )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waFieldCount(%p, %p)", pArea, uiFields));
* uiFields = pArea->uiFieldCount;
return SUCCESS;
}
| workarea.c | 467 |
| STATIC ERRCODE | hb_waFieldInfo( AREAP pArea, USHORT uiIndex, USHORT uiType, PHB_ITEM pItem )
static ERRCODE hb_waFieldInfo( AREAP pArea, USHORT uiIndex, USHORT uiType, PHB_ITEM pItem )
{
LPFIELD pField;
HB_TRACE(HB_TR_DEBUG, ("hb_waFieldInfo(%p, %hu, %hu, %p)", pArea, uiIndex, uiType, pItem));
if( uiIndex > pArea->uiFieldCount )
return FAILURE;
pField = pArea->lpFields + uiIndex - 1;
switch( uiType )
{
case DBS_NAME:
hb_itemPutC( pItem, hb_dynsymName( ( PHB_DYNS ) pField->sym ) );
break;
case DBS_TYPE:
switch( pField->uiType )
{
case HB_FT_STRING:
hb_itemPutC( pItem, "C" );
break;
case HB_FT_LOGICAL:
hb_itemPutC( pItem, "L" );
break;
case HB_FT_DATE:
hb_itemPutC( pItem, "D" );
break;
case HB_FT_LONG:
hb_itemPutC( pItem, "N" );
break;
case HB_FT_INTEGER:
hb_itemPutC( pItem, "I" );
break;
case HB_FT_DOUBLE:
hb_itemPutC( pItem, "B" );
break;
case HB_FT_FLOAT:
hb_itemPutC( pItem, "F" );
break;
case HB_FT_TIME:
hb_itemPutC( pItem, "T" );
break;
case HB_FT_DAYTIME:
hb_itemPutC( pItem, "@" );
break;
case HB_FT_MODTIME:
hb_itemPutC( pItem, "=" );
break;
case HB_FT_ROWVER:
hb_itemPutC( pItem, "^" );
break;
case HB_FT_AUTOINC:
hb_itemPutC( pItem, "+" );
break;
case HB_FT_CURRENCY:
hb_itemPutC( pItem, "Y" );
break;
case HB_FT_CURDOUBLE:
hb_itemPutC( pItem, "Z" );
break;
case HB_FT_VARLENGTH:
hb_itemPutC( pItem, "Q" );
break;
case HB_FT_MEMO:
hb_itemPutC( pItem, "M" );
break;
case HB_FT_ANY:
hb_itemPutC( pItem, "V" );
break;
case HB_FT_IMAGE:
hb_itemPutC( pItem, "P" );
break;
case HB_FT_BLOB:
hb_itemPutC( pItem, "W" );
break;
case HB_FT_OLE:
hb_itemPutC( pItem, "G" );
break;
default:
hb_itemPutC( pItem, "U" );
break;
}
break;
case DBS_LEN:
hb_itemPutNL( pItem, pField->uiLen );
break;
case DBS_DEC:
hb_itemPutNL( pItem, pField->uiDec );
break;
#ifdef DBS_FLAG
case DBS_FLAG:
hb_itemPutNL( pItem, pField->uiFlags );
break;
#endif
default:
return FAILURE;
}
return SUCCESS;
}
| workarea.c | 478 |
| STATIC ERRCODE | hb_waFieldName( AREAP pArea, USHORT uiIndex, void * szName )
static ERRCODE hb_waFieldName( AREAP pArea, USHORT uiIndex, void * szName )
{
LPFIELD pField;
HB_TRACE(HB_TR_DEBUG, ("hb_waFieldName(%p, %hu, %p)", pArea, uiIndex, szName));
if( uiIndex > pArea->uiFieldExtent )
return FAILURE;
pField = pArea->lpFields + uiIndex - 1;
hb_strncpy( ( char * ) szName, hb_dynsymName( ( PHB_DYNS ) pField->sym ),
pArea->uiMaxFieldNameLength );
return SUCCESS;
}
| workarea.c | 607 |
| STATIC ERRCODE | hb_waSetFieldExtent( AREAP pArea, USHORT uiFieldExtent )
static ERRCODE hb_waSetFieldExtent( AREAP pArea, USHORT uiFieldExtent )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waSetFieldExtent(%p, %hu)", pArea, uiFieldExtent));
pArea->uiFieldExtent = uiFieldExtent;
/* Alloc field array */
if( uiFieldExtent )
{
pArea->lpFields = ( LPFIELD ) hb_xgrab( uiFieldExtent * sizeof( FIELD ) );
memset( pArea->lpFields, 0, uiFieldExtent * sizeof( FIELD ) );
}
return SUCCESS;
}
| workarea.c | 625 |
| STATIC ERRCODE | hb_waAlias( AREAP pArea, BYTE * szAlias )
static ERRCODE hb_waAlias( AREAP pArea, BYTE * szAlias )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waAlias(%p, %p)", pArea, szAlias));
hb_strncpy( ( char * ) szAlias,
pArea->atomAlias && hb_dynsymAreaHandle( ( PHB_DYNS ) pArea->atomAlias )
? hb_dynsymName( ( PHB_DYNS ) pArea->atomAlias ) : "",
HB_RDD_MAX_ALIAS_LEN );
return SUCCESS;
}
| workarea.c | 644 |
| STATIC ERRCODE | hb_waClose( AREAP pArea )
static ERRCODE hb_waClose( AREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waClose(%p)", pArea));
/* Clear items */
SELF_CLEARFILTER( pArea );
SELF_CLEARREL( pArea );
SELF_CLEARLOCATE( pArea );
/* Clear relations that has this area as a child */
hb_rddCloseAllParentRelations( pArea );
if( pArea->atomAlias )
hb_dynsymSetAreaHandle( ( PHB_DYNS ) pArea->atomAlias, 0 );
return SUCCESS;
}
| workarea.c | 659 |
| STATIC ERRCODE | hb_waInfo( AREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
static ERRCODE hb_waInfo( AREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waInfo(%p, %hu, %p)", pArea, uiIndex, pItem));
switch( uiIndex )
{
case DBI_ISDBF:
case DBI_CANPUTREC:
case DBI_ISFLOCK:
case DBI_SHARED:
hb_itemPutL( pItem, FALSE );
break;
/*
* IMHO better to return FAILURE to notice that it's not supported
*/
case DBI_GETDELIMITER:
case DBI_SETDELIMITER:
case DBI_SEPARATOR:
hb_itemPutC( pItem, NULL );
return FAILURE;
case DBI_GETHEADERSIZE:
case DBI_GETRECSIZE:
case DBI_LOCKCOUNT:
hb_itemPutNI( pItem, 0 );
break;
case DBI_LASTUPDATE:
hb_itemPutDL( pItem, 0 );
break;
case DBI_GETLOCKARRAY:
hb_arrayNew( pItem, 0 );
break;
case DBI_CHILDCOUNT:
{
LPDBRELINFO lpdbRelations = pArea->lpdbRelations;
USHORT uiCount = 0;
while( lpdbRelations )
{
uiCount++;
lpdbRelations = lpdbRelations->lpdbriNext;
}
hb_itemPutNI( pItem, uiCount );
break;
}
case DBI_BOF:
hb_itemPutL( pItem, pArea->fBof );
break;
case DBI_EOF:
hb_itemPutL( pItem, pArea->fEof );
break;
case DBI_DBFILTER:
if( pArea->dbfi.abFilterText )
hb_itemCopy( pItem, pArea->dbfi.abFilterText );
else
hb_itemPutC( pItem, NULL );
break;
case DBI_FOUND:
hb_itemPutL( pItem, pArea->fFound );
break;
case DBI_FCOUNT:
hb_itemPutNI( pItem, pArea->uiFieldCount );
break;
case DBI_ALIAS:
{
char szAlias[ HB_RDD_MAX_ALIAS_LEN + 1 ];
if( SELF_ALIAS( pArea, ( BYTE * ) szAlias ) != SUCCESS )
{
return FAILURE;
}
hb_itemPutC( pItem, szAlias );
break;
}
case DBI_TABLEEXT:
hb_itemClear( pItem );
return SELF_RDDINFO( SELF_RDDNODE( pArea ), RDDI_TABLEEXT, 0, pItem );
case DBI_SCOPEDRELATION:
{
int iRelNo = hb_itemGetNI( pItem );
BOOL fScoped = FALSE;
if( iRelNo > 0 )
{
LPDBRELINFO lpdbRelations = pArea->lpdbRelations;
while( lpdbRelations )
{
if( --iRelNo == 0 )
{
fScoped = lpdbRelations->isScoped;
break;
}
lpdbRelations = lpdbRelations->lpdbriNext;
}
}
hb_itemPutL( pItem, fScoped );
break;
}
case DBI_POSITIONED:
{
ULONG ulRecCount, ulRecNo;
if( SELF_RECNO( pArea, &ulRecNo ) != SUCCESS )
return FAILURE;
if( ulRecNo == 0 )
hb_itemPutL( pItem, FALSE );
else if( SELF_RECCOUNT( pArea, &ulRecCount ) != SUCCESS )
return FAILURE;
else
hb_itemPutL( pItem, ulRecNo != ulRecCount + 1 );
break;
}
case DBI_RM_SUPPORTED:
hb_itemPutL( pItem, FALSE );
break;
case DBI_DB_VERSION:
hb_itemPutC( pItem, NULL );
break;
case DBI_RDD_VERSION:
hb_itemPutC( pItem, NULL );
break;
default:
return FAILURE;
}
return SUCCESS;
}
| workarea.c | 680 |
| STATIC ERRCODE | hb_waOrderInfo( AREAP pArea, USHORT index, LPDBORDERINFO pInfo )
static ERRCODE hb_waOrderInfo( AREAP pArea, USHORT index, LPDBORDERINFO pInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waOrderInfo(%p, %hu, %p)", pArea, index, pInfo));
HB_SYMBOL_UNUSED( pArea );
HB_SYMBOL_UNUSED( index );
if( pInfo->itmResult )
hb_itemClear( pInfo->itmResult );
/* CA-Cl*pper does not generate RT error when default ORDERINFO() method
* is called
*/
/* hb_errRT_DBCMD( EG_ARG, EDBCMD_BADPARAMETER, NULL, HB_ERR_FUNCNAME ); */
return FAILURE;
}
| workarea.c | 822 |
| STATIC ERRCODE | hb_waNewArea( AREAP pArea )
static ERRCODE hb_waNewArea( AREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waNewArea(%p)", pArea));
pArea->valResult = hb_itemNew( NULL );
pArea->lpdbRelations = NULL;
pArea->uiParents = 0;
pArea->uiMaxFieldNameLength = 10;
return SUCCESS;
}
| workarea.c | 844 |
| STATIC ERRCODE | hb_waOpen( AREAP pArea, LPDBOPENINFO pInfo )
static ERRCODE hb_waOpen( AREAP pArea, LPDBOPENINFO pInfo )
{
if( !pArea->atomAlias && pInfo->atomAlias && pInfo->atomAlias[ 0 ] )
{
pArea->atomAlias = hb_rddAllocWorkAreaAlias( ( char * ) pInfo->atomAlias,
( int ) pInfo->uiArea );
if( ! pArea->atomAlias )
{
SELF_CLOSE( ( AREAP ) pArea );
return FAILURE;
}
}
return SUCCESS;
}
| workarea.c | 859 |
| STATIC ERRCODE | hb_waOrderCondition( AREAP pArea, LPDBORDERCONDINFO param )
static ERRCODE hb_waOrderCondition( AREAP pArea, LPDBORDERCONDINFO param )
{
if( pArea->lpdbOrdCondInfo )
{
if( pArea->lpdbOrdCondInfo->abFor )
hb_xfree( pArea->lpdbOrdCondInfo->abFor );
if( pArea->lpdbOrdCondInfo->abWhile )
hb_xfree( pArea->lpdbOrdCondInfo->abWhile );
if( pArea->lpdbOrdCondInfo->itmCobFor )
{
hb_itemRelease( pArea->lpdbOrdCondInfo->itmCobFor );
}
if( pArea->lpdbOrdCondInfo->itmCobWhile )
{
hb_itemRelease( pArea->lpdbOrdCondInfo->itmCobWhile );
}
if( pArea->lpdbOrdCondInfo->itmCobEval )
{
hb_itemRelease( pArea->lpdbOrdCondInfo->itmCobEval );
}
if( pArea->lpdbOrdCondInfo->itmStartRecID )
{
hb_itemRelease( pArea->lpdbOrdCondInfo->itmStartRecID );
}
if( pArea->lpdbOrdCondInfo->itmRecID )
{
hb_itemRelease( pArea->lpdbOrdCondInfo->itmRecID );
}
hb_xfree( pArea->lpdbOrdCondInfo );
}
pArea->lpdbOrdCondInfo = param;
return SUCCESS;
}
| workarea.c | 878 |
| STATIC ERRCODE | hb_waRelease( AREAP pArea )
static ERRCODE hb_waRelease( AREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waRelease(%p)", pArea));
/* Free all allocated pointers */
if( pArea->lpFields )
hb_xfree( pArea->lpFields );
if( pArea->valResult )
hb_itemRelease( pArea->valResult );
if( pArea->lpdbOrdCondInfo )
/* intentionally direct call not a method */
hb_waOrderCondition( pArea,NULL );
hb_xfree( pArea );
return SUCCESS;
}
| workarea.c | 913 |
| STATIC ERRCODE | hb_waStructSize( AREAP pArea, USHORT * uiSize )
static ERRCODE hb_waStructSize( AREAP pArea, USHORT * uiSize )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waStrucSize(%p, %p)", pArea, uiSize));
HB_SYMBOL_UNUSED( pArea );
* uiSize = sizeof( AREA );
return SUCCESS;
}
| workarea.c | 932 |
| STATIC ERRCODE | hb_waSysName( AREAP pArea, BYTE * pBuffer )
static ERRCODE hb_waSysName( AREAP pArea, BYTE * pBuffer )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waSysName(%p, %p)", pArea, pBuffer));
hb_strncpy( ( char * ) pBuffer, SELF_RDDNODE( pArea )->szName,
HB_RDD_MAX_DRIVERNAME_LEN );
return SUCCESS;
}
| workarea.c | 944 |
| STATIC ERRCODE | hb_waEval( AREAP pArea, LPDBEVALINFO pEvalInfo )
static ERRCODE hb_waEval( AREAP pArea, LPDBEVALINFO pEvalInfo )
{
LONG lNext = 1;
BOOL fEof, fFor;
HB_TRACE(HB_TR_DEBUG, ("hb_waEval(%p, %p)", pArea, pEvalInfo));
if( pEvalInfo->dbsci.itmRecID )
{
if( SELF_GOTOID( pArea, pEvalInfo->dbsci.itmRecID ) != SUCCESS )
return FAILURE;
}
else if( pEvalInfo->dbsci.lNext )
{
lNext = hb_itemGetNL( pEvalInfo->dbsci.lNext );
}
else if( !pEvalInfo->dbsci.itmCobWhile &&
!hb_itemGetL( pEvalInfo->dbsci.fRest ) )
{
if( SELF_GOTOP( pArea ) != SUCCESS )
return FAILURE;
}
/* TODO: use SKIPSCOPE() method and fRest parameter */
if( !pEvalInfo->dbsci.lNext || lNext > 0 )
{
for( ;; )
{
if( SELF_EOF( pArea, &fEof ) != SUCCESS )
return FAILURE;
if( fEof )
break;
if( pEvalInfo->dbsci.itmCobWhile )
{
if( SELF_EVALBLOCK( pArea, pEvalInfo->dbsci.itmCobWhile ) != SUCCESS )
return FAILURE;
if( ! hb_itemGetL( pArea->valResult ) )
break;
}
if( pEvalInfo->dbsci.itmCobFor )
{
if( SELF_EVALBLOCK( pArea, pEvalInfo->dbsci.itmCobFor ) != SUCCESS )
return FAILURE;
fFor = hb_itemGetL( pArea->valResult );
}
else
fFor = TRUE;
if( fFor )
{
if( SELF_EVALBLOCK( pArea, pEvalInfo->itmBlock ) != SUCCESS )
return FAILURE;
}
if( pEvalInfo->dbsci.itmRecID || ( pEvalInfo->dbsci.lNext && --lNext < 1 ) )
break;
if( SELF_SKIP( pArea, 1 ) != SUCCESS )
return FAILURE;
}
}
return SUCCESS;
}
| workarea.c | 957 |
| STATIC ERRCODE | hb_waLocate( AREAP pArea, BOOL fContinue )
static ERRCODE hb_waLocate( AREAP pArea, BOOL fContinue )
{
LONG lNext = 1;
BOOL fEof;
HB_TRACE(HB_TR_DEBUG, ("hb_waLocate(%p, %d)", pArea, fContinue));
if( fContinue )
{
if( ! pArea->dbsi.itmCobFor )
return SUCCESS;
if( SELF_SKIP( pArea, 1 ) != SUCCESS )
return FAILURE;
}
else if( pArea->dbsi.itmRecID )
{
if( SELF_GOTOID( pArea, pArea->dbsi.itmRecID ) != SUCCESS )
return FAILURE;
}
else if( pArea->dbsi.lNext )
{
lNext = hb_itemGetNL( pArea->dbsi.lNext );
}
else if( !pArea->dbsi.itmCobWhile &&
!hb_itemGetL( pArea->dbsi.fRest ) )
{
if( SELF_GOTOP( pArea ) != SUCCESS )
return FAILURE;
}
pArea->fFound = FALSE;
/* TODO: use SKIPSCOPE() method and fRest parameter */
if( !pArea->dbsi.lNext || lNext > 0 )
{
for( ;; )
{
if( SELF_EOF( pArea, &fEof ) != SUCCESS )
return FAILURE;
if( fEof )
break;
if( !fContinue && pArea->dbsi.itmCobWhile )
{
if( SELF_EVALBLOCK( pArea, pArea->dbsi.itmCobWhile ) != SUCCESS )
return FAILURE;
if( ! hb_itemGetL( pArea->valResult ) )
break;
}
if( ! pArea->dbsi.itmCobFor )
{
pArea->fFound = TRUE;
break;
}
else
{
if( SELF_EVALBLOCK( pArea, pArea->dbsi.itmCobFor ) != SUCCESS )
return FAILURE;
if( hb_itemGetL( pArea->valResult ) )
{
pArea->fFound = TRUE;
break;
}
}
if( !fContinue &&
( pArea->dbsi.itmRecID || ( pArea->dbsi.lNext && --lNext < 1 ) ) )
break;
if( SELF_SKIP( pArea, 1 ) != SUCCESS )
return FAILURE;
}
}
return SUCCESS;
}
| workarea.c | 1029 |
| STATIC ERRCODE | hb_waTrans( AREAP pArea, LPDBTRANSINFO pTransInfo )
static ERRCODE hb_waTrans( AREAP pArea, LPDBTRANSINFO pTransInfo )
{
LONG lNext = 1;
BOOL fEof, fFor;
HB_TRACE(HB_TR_DEBUG, ("hb_waTrans(%p, %p)", pArea, pTransInfo));
if( pTransInfo->dbsci.itmRecID )
{
if( SELF_GOTOID( pArea, pTransInfo->dbsci.itmRecID ) != SUCCESS )
return FAILURE;
}
else if( pTransInfo->dbsci.lNext )
{
lNext = hb_itemGetNL( pTransInfo->dbsci.lNext );
}
else if( !pTransInfo->dbsci.itmCobWhile &&
!hb_itemGetL( pTransInfo->dbsci.fRest ) )
{
if( SELF_GOTOP( pArea ) != SUCCESS )
return FAILURE;
}
/* TODO: use SKIPSCOPE() method and fRest parameter */
if( !pTransInfo->dbsci.lNext || lNext > 0 )
{
for( ;; )
{
if( SELF_EOF( pArea, &fEof ) != SUCCESS )
return FAILURE;
if( fEof )
break;
if( pTransInfo->dbsci.itmCobWhile )
{
if( SELF_EVALBLOCK( pArea, pTransInfo->dbsci.itmCobWhile ) != SUCCESS )
return FAILURE;
if( ! hb_itemGetL( pArea->valResult ) )
break;
}
if( pTransInfo->dbsci.itmCobFor )
{
if( SELF_EVALBLOCK( pArea, pTransInfo->dbsci.itmCobFor ) != SUCCESS )
return FAILURE;
fFor = hb_itemGetL( pArea->valResult );
}
else
fFor = TRUE;
if( fFor )
{
if( SELF_TRANSREC( pArea, pTransInfo ) != SUCCESS )
return FAILURE;
}
if( pTransInfo->dbsci.itmRecID || ( pTransInfo->dbsci.lNext && --lNext < 1 ) )
break;
if( SELF_SKIP( pArea, 1 ) != SUCCESS )
return FAILURE;
}
}
return SUCCESS;
}
| workarea.c | 1114 |
| STATIC ERRCODE | hb_waTransRec( AREAP pArea, LPDBTRANSINFO pTransInfo )
static ERRCODE hb_waTransRec( AREAP pArea, LPDBTRANSINFO pTransInfo )
{
BOOL bDeleted;
BYTE *pRecord;
ERRCODE errCode;
HB_TRACE(HB_TR_DEBUG, ("hb_waTransRec(%p, %p)", pArea, pTransInfo));
/* Record deleted? */
errCode = SELF_DELETED( ( AREAP ) pArea, &bDeleted );
if( errCode != SUCCESS )
return errCode;
if( pTransInfo->uiFlags & DBTF_MATCH && pTransInfo->uiFlags & DBTF_PUTREC )
{
errCode = SELF_GETREC( ( AREAP ) pArea, &pRecord );
if( errCode != SUCCESS )
return errCode;
/* Append a new record */
errCode = SELF_APPEND( ( AREAP ) pTransInfo->lpaDest, TRUE );
if( errCode != SUCCESS )
return errCode;
/* Copy record */
errCode = SELF_PUTREC( ( AREAP ) pTransInfo->lpaDest, pRecord );
}
else
{
LPDBTRANSITEM pTransItem;
PHB_ITEM pItem;
USHORT uiCount;
/* Append a new record */
errCode = SELF_APPEND( ( AREAP ) pTransInfo->lpaDest, TRUE );
if( errCode != SUCCESS )
return errCode;
pItem = hb_itemNew( NULL );
pTransItem = pTransInfo->lpTransItems;
for( uiCount = pTransInfo->uiItemCount; uiCount; --uiCount )
{
errCode = SELF_GETVALUE( ( AREAP ) pArea,
pTransItem->uiSource, pItem );
if( errCode != SUCCESS )
break;
errCode = SELF_PUTVALUE( ( AREAP ) pTransInfo->lpaDest,
pTransItem->uiDest, pItem );
if( errCode != SUCCESS )
break;
++pTransItem;
}
hb_itemRelease( pItem );
}
/* Delete the new record if copy fail */
if( errCode != SUCCESS )
{
SELF_DELETE( ( AREAP ) pTransInfo->lpaDest );
return errCode;
}
/* Delete the new record */
if( bDeleted )
return SELF_DELETE( ( AREAP ) pTransInfo->lpaDest );
return SUCCESS;
}
| workarea.c | 1186 |
| STATIC ERRCODE | hb_waChildEnd( AREAP pArea, LPDBRELINFO pRelInfo )
static ERRCODE hb_waChildEnd( AREAP pArea, LPDBRELINFO pRelInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waChildEnd(%p, %p)", pArea, pRelInfo));
if( pRelInfo->isScoped )
{
DBORDERINFO pInfo;
pInfo.itmOrder = NULL;
pInfo.atomBagName = NULL;
pInfo.itmResult = hb_itemNew( NULL );
pInfo.itmNewVal = NULL;
SELF_ORDINFO( pArea, DBOI_SCOPETOPCLEAR, &pInfo );
SELF_ORDINFO( pArea, DBOI_SCOPEBOTTOMCLEAR, &pInfo );
hb_itemRelease( pInfo.itmResult );
}
pArea->uiParents--;
return SUCCESS;
}
| workarea.c | 1258 |
| STATIC ERRCODE | hb_waChildStart( AREAP pArea, LPDBRELINFO pRelInfo )
static ERRCODE hb_waChildStart( AREAP pArea, LPDBRELINFO pRelInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waChildStart(%p, %p)", pArea, pRelInfo));
HB_SYMBOL_UNUSED( pRelInfo );
pArea->uiParents ++;
return SUCCESS;
}
| workarea.c | 1281 |
| STATIC ERRCODE | hb_waSyncChildren( AREAP pArea )
static ERRCODE hb_waSyncChildren( AREAP pArea )
{
LPDBRELINFO lpdbRelation;
HB_TRACE(HB_TR_DEBUG, ("hb_waSyncChildren(%p)", pArea));
lpdbRelation = pArea->lpdbRelations;
while( lpdbRelation )
{
if( SELF_CHILDSYNC( lpdbRelation->lpaChild, lpdbRelation ) != SUCCESS )
return FAILURE;
lpdbRelation = lpdbRelation->lpdbriNext;
}
return SUCCESS;
}
| workarea.c | 1293 |
| STATIC ERRCODE | hb_waClearRel( AREAP pArea )
static ERRCODE hb_waClearRel( AREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waClearRel(%p)", pArea ));
/* Free all relations */
if( pArea->lpdbRelations )
{
int iCurrArea = hb_rddGetCurrentWorkAreaNumber();
do
{
LPDBRELINFO lpdbRelation = pArea->lpdbRelations;
hb_rddSelectWorkAreaNumber( lpdbRelation->lpaChild->uiArea );
SELF_CHILDEND( lpdbRelation->lpaChild, lpdbRelation );
pArea->lpdbRelations = lpdbRelation->lpdbriNext;
if( lpdbRelation->itmCobExpr )
{
hb_itemRelease( lpdbRelation->itmCobExpr );
}
if( lpdbRelation->abKey )
{
hb_itemRelease( lpdbRelation->abKey );
}
hb_xfree( lpdbRelation );
}
while( pArea->lpdbRelations );
hb_rddSelectWorkAreaNumber( iCurrArea );
}
return SUCCESS;
}
| workarea.c | 1313 |
| STATIC ERRCODE | hb_waRelArea( AREAP pArea, USHORT uiRelNo, void * pRelArea )
static ERRCODE hb_waRelArea( AREAP pArea, USHORT uiRelNo, void * pRelArea )
{
LPDBRELINFO lpdbRelations;
USHORT uiIndex = 1;
USHORT * pWA = (USHORT *) pRelArea;
/*TODO: Why pRelArea declared as void*? This creates casting hassles.*/
HB_TRACE(HB_TR_DEBUG, ("hb_waRelArea(%p, %hu, %p)", pArea, uiRelNo, pRelArea));
*pWA = 0;
lpdbRelations = pArea->lpdbRelations;
while( lpdbRelations )
{
if( uiIndex++ == uiRelNo )
{
*pWA = lpdbRelations->lpaChild->uiArea;
break;
}
lpdbRelations = lpdbRelations->lpdbriNext;
}
return *pWA ? SUCCESS : FAILURE;
}
| workarea.c | 1351 |
| STATIC ERRCODE | hb_waRelEval( AREAP pArea, LPDBRELINFO pRelInfo )
static ERRCODE hb_waRelEval( AREAP pArea, LPDBRELINFO pRelInfo )
{
PHB_ITEM pResult;
DBORDERINFO pInfo;
ERRCODE errCode;
int iOrder;
HB_TRACE(HB_TR_DEBUG, ("hb_waRelEval(%p, %p)", pArea, pRelInfo));
errCode = SELF_EVALBLOCK( pRelInfo->lpaParent, pRelInfo->itmCobExpr );
if( errCode == SUCCESS )
{
/*
* Check the current order
*/
pResult = pRelInfo->lpaParent->valResult;
pRelInfo->lpaParent->valResult = NULL;
memset( &pInfo, 0, sizeof( DBORDERINFO ) );
pInfo.itmResult = hb_itemPutNI( NULL, 0 );
errCode = SELF_ORDINFO( pArea, DBOI_NUMBER, &pInfo );
if( errCode == SUCCESS )
{
iOrder = hb_itemGetNI( pInfo.itmResult );
if( iOrder != 0 )
{
if( pRelInfo->isScoped )
{
pInfo.itmNewVal = pResult;
errCode = SELF_ORDINFO( pArea, DBOI_SCOPETOP, &pInfo );
if( errCode == SUCCESS )
errCode = SELF_ORDINFO( pArea, DBOI_SCOPEBOTTOM, &pInfo );
}
if( errCode == SUCCESS )
errCode = SELF_SEEK( pArea, FALSE, pResult, FALSE );
}
else
{
/*
* If current order equals to zero, use GOTOID instead of SEEK
* Unfortunately it interacts with buggy .prg code which returns
* non numerical values from relation expression and RDD accepts
* only numerical record ID. In such case SELF_GOTO() works like
* SELF_GOEOF() but SELF_GOTOID() reports error. So for Clipper
* compatibility SELF_GOTO() is used here but if RDD can use
* non numerical record IDs then this method should be overloaded
* to use SELF_GOTOID(), [druzus]
*/
/* errCode = SELF_GOTOID( pArea, pResult ); */
errCode = SELF_GOTO( pArea, hb_itemGetNL( pResult ) );
}
}
hb_itemRelease( pInfo.itmResult );
hb_itemRelease( pResult );
}
return errCode;
}
| workarea.c | 1377 |
| STATIC ERRCODE | hb_waRelText( AREAP pArea, USHORT uiRelNo, PHB_ITEM pExpr )
static ERRCODE hb_waRelText( AREAP pArea, USHORT uiRelNo, PHB_ITEM pExpr )
{
LPDBRELINFO lpdbRelations;
USHORT uiIndex = 1;
HB_TRACE(HB_TR_DEBUG, ("hb_waRelText(%p, %hu, %p)", pArea, uiRelNo, pExpr));
lpdbRelations = pArea->lpdbRelations;
while( lpdbRelations )
{
if( uiIndex++ == uiRelNo )
{
hb_itemCopy( pExpr, lpdbRelations->abKey );
return SUCCESS;
}
lpdbRelations = lpdbRelations->lpdbriNext;
}
return FAILURE;
}
| workarea.c | 1440 |
| STATIC ERRCODE | hb_waSetRel( AREAP pArea, LPDBRELINFO lpdbRelInf )
static ERRCODE hb_waSetRel( AREAP pArea, LPDBRELINFO lpdbRelInf )
{
LPDBRELINFO lpdbRelations;
HB_TRACE(HB_TR_DEBUG, ("hb_waSetRel(%p, %p)", pArea, lpdbRelInf));
lpdbRelations = pArea->lpdbRelations;
if( ! lpdbRelations )
{
pArea->lpdbRelations = ( LPDBRELINFO ) hb_xgrab( sizeof( DBRELINFO ) );
lpdbRelations = pArea->lpdbRelations;
}
else
{
while( lpdbRelations->lpdbriNext )
lpdbRelations = lpdbRelations->lpdbriNext;
lpdbRelations->lpdbriNext = ( LPDBRELINFO ) hb_xgrab( sizeof( DBRELINFO ) );
lpdbRelations = lpdbRelations->lpdbriNext;
}
lpdbRelations->lpaParent = pArea;
lpdbRelations->lpaChild = lpdbRelInf->lpaChild;
lpdbRelations->itmCobExpr = lpdbRelInf->itmCobExpr;
lpdbRelations->isScoped = lpdbRelInf->isScoped;
lpdbRelations->isOptimized = lpdbRelInf->isOptimized;
lpdbRelations->abKey = lpdbRelInf->abKey;
lpdbRelations->lpdbriNext = lpdbRelInf->lpdbriNext;
return SELF_CHILDSTART( ( AREAP ) lpdbRelInf->lpaChild, lpdbRelations );
}
| workarea.c | 1465 |
| STATIC ERRCODE | hb_waClearFilter( AREAP pArea )
static ERRCODE hb_waClearFilter( AREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waClearFilter(%p)", pArea));
/* Free all items */
if( pArea->dbfi.itmCobExpr )
{
hb_itemRelease( pArea->dbfi.itmCobExpr );
pArea->dbfi.itmCobExpr = NULL;
}
if( pArea->dbfi.abFilterText )
{
hb_itemRelease( pArea->dbfi.abFilterText );
pArea->dbfi.abFilterText = NULL;
}
pArea->dbfi.fOptimized = FALSE;
pArea->dbfi.fFilter = FALSE;
return SUCCESS;
}
| workarea.c | 1498 |
| STATIC ERRCODE | hb_waClearLocate( AREAP pArea )
static ERRCODE hb_waClearLocate( AREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waClearLocate(%p)", pArea));
/* Free all items */
if( pArea->dbsi.itmCobFor )
{
hb_itemRelease( pArea->dbsi.itmCobFor );
pArea->dbsi.itmCobFor = NULL;
}
if( pArea->dbsi.lpstrFor )
{
hb_itemRelease( pArea->dbsi.lpstrFor );
pArea->dbsi.lpstrFor = NULL;
}
if( pArea->dbsi.itmCobWhile )
{
hb_itemRelease( pArea->dbsi.itmCobWhile );
pArea->dbsi.itmCobWhile = NULL;
}
if( pArea->dbsi.lpstrWhile )
{
hb_itemRelease( pArea->dbsi.lpstrWhile );
pArea->dbsi.lpstrWhile = NULL;
}
if( pArea->dbsi.lNext )
{
hb_itemRelease( pArea->dbsi.lNext );
pArea->dbsi.lNext = NULL;
}
if( pArea->dbsi.itmRecID )
{
hb_itemRelease( pArea->dbsi.itmRecID );
pArea->dbsi.itmRecID = NULL;
}
if( pArea->dbsi.fRest )
{
hb_itemRelease( pArea->dbsi.fRest );
pArea->dbsi.fRest = NULL;
}
return SUCCESS;
}
| workarea.c | 1522 |
| STATIC ERRCODE | hb_waFilterText( AREAP pArea, PHB_ITEM pFilter )
static ERRCODE hb_waFilterText( AREAP pArea, PHB_ITEM pFilter )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waFilterText(%p, %p)", pArea, pFilter));
if( pArea->dbfi.abFilterText )
hb_itemCopy( pFilter, pArea->dbfi.abFilterText );
return SUCCESS;
}
| workarea.c | 1569 |
| STATIC ERRCODE | hb_waSetFilter( AREAP pArea, LPDBFILTERINFO pFilterInfo )
static ERRCODE hb_waSetFilter( AREAP pArea, LPDBFILTERINFO pFilterInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waSetFilter(%p, %p)", pArea, pFilterInfo));
/* Clear the active filter expression */
if( SELF_CLEARFILTER( pArea ) != SUCCESS )
return FAILURE;
if( pFilterInfo->itmCobExpr )
{
pArea->dbfi.itmCobExpr = hb_itemNew( pFilterInfo->itmCobExpr );
}
if( pFilterInfo->abFilterText )
{
pArea->dbfi.abFilterText = hb_itemNew( pFilterInfo->abFilterText );
}
pArea->dbfi.fOptimized = pFilterInfo->fOptimized;
pArea->dbfi.fFilter = TRUE;
return SUCCESS;
}
| workarea.c | 1582 |
| STATIC ERRCODE | hb_waSetLocate( AREAP pArea, LPDBSCOPEINFO pScopeInfo )
static ERRCODE hb_waSetLocate( AREAP pArea, LPDBSCOPEINFO pScopeInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waSetLocate(%p, %p)", pArea, pScopeInfo));
/* Clear the active locate expression */
if( SELF_CLEARLOCATE( pArea ) != SUCCESS )
return FAILURE;
if( pScopeInfo->itmCobFor )
pArea->dbsi.itmCobFor = hb_itemNew( pScopeInfo->itmCobFor );
if( pScopeInfo->lpstrFor )
pArea->dbsi.lpstrFor = hb_itemNew( pScopeInfo->lpstrFor );
if( pScopeInfo->itmCobWhile )
pArea->dbsi.itmCobWhile = hb_itemNew( pScopeInfo->itmCobWhile );
if( pScopeInfo->lpstrWhile )
pArea->dbsi.lpstrWhile = hb_itemNew( pScopeInfo->lpstrWhile );
if( pScopeInfo->lNext )
pArea->dbsi.lNext = hb_itemNew( pScopeInfo->lNext );
if( pScopeInfo->itmRecID )
pArea->dbsi.itmRecID = hb_itemNew( pScopeInfo->itmRecID );
if( pScopeInfo->fRest )
pArea->dbsi.fRest = hb_itemNew( pScopeInfo->fRest );
pArea->dbsi.fIgnoreFilter = pScopeInfo->fIgnoreFilter;
pArea->dbsi.fIncludeDeleted = pScopeInfo->fIncludeDeleted;
pArea->dbsi.fLast = pScopeInfo->fLast;
pArea->dbsi.fIgnoreDuplicates = pScopeInfo->fIgnoreDuplicates;
pArea->dbsi.fBackward = pScopeInfo->fBackward;
pArea->dbsi.fOptimized = pScopeInfo->fOptimized;
return SUCCESS;
}
| workarea.c | 1607 |
| STATIC ERRCODE | hb_waCompile( AREAP pArea, BYTE * pExpr )
static ERRCODE hb_waCompile( AREAP pArea, BYTE * pExpr )
{
HB_MACRO_PTR pMacro;
HB_TRACE(HB_TR_DEBUG, ("hb_waCompile(%p, %p)", pArea, pExpr));
pMacro = hb_macroCompile( ( char * ) pExpr );
if( pMacro )
{
pArea->valResult = hb_itemPutPtr( pArea->valResult, ( void * ) pMacro );
return SUCCESS;
}
else
return FAILURE;
}
| workarea.c | 1649 |
| STATIC ERRCODE | hb_waError( AREAP pArea, PHB_ITEM pError )
static ERRCODE hb_waError( AREAP pArea, PHB_ITEM pError )
{
char * szRddName;
HB_TRACE(HB_TR_DEBUG, ("hb_waError(%p, %p)", pArea, pError));
szRddName = ( char * ) hb_xgrab( HB_RDD_MAX_DRIVERNAME_LEN + 1 );
if( pArea && pArea->lprfsHost->sysName )
SELF_SYSNAME( pArea, ( BYTE * ) szRddName );
else
hb_strncpy( szRddName, "???DRIVER", HB_RDD_MAX_DRIVERNAME_LEN );
hb_errPutSeverity( pError, ES_ERROR );
hb_errPutSubSystem( pError, szRddName );
hb_xfree( szRddName );
return hb_errLaunch( pError );
}
| workarea.c | 1668 |
| STATIC ERRCODE | hb_waEvalBlock( AREAP pArea, PHB_ITEM pBlock )
static ERRCODE hb_waEvalBlock( AREAP pArea, PHB_ITEM pBlock )
{
PHB_ITEM pItem;
int iCurrArea;
HB_TRACE(HB_TR_DEBUG, ("hb_waEvalBlock(%p, %p)", pArea, pBlock));
iCurrArea = hb_rddGetCurrentWorkAreaNumber();
if( iCurrArea != pArea->uiArea )
hb_rddSelectWorkAreaNumber( pArea->uiArea );
pItem = hb_vmEvalBlockOrMacro( pBlock );
if( ! pArea->valResult )
pArea->valResult = hb_itemNew( NULL );
hb_itemCopy( pArea->valResult, pItem );
hb_rddSelectWorkAreaNumber( iCurrArea );
return hb_vmRequestQuery() ? FAILURE : SUCCESS;
}
| workarea.c | 1688 |
| STATIC ERRCODE | hb_waRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnection, PHB_ITEM pItem )
static ERRCODE hb_waRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnection, PHB_ITEM pItem )
{
BOOL fResult;
int iResult;
HB_TRACE(HB_TR_DEBUG, ("hb_rddInfo(%p, %hu, %lu, %p)", pRDD, uiIndex, ulConnection, pItem));
HB_SYMBOL_UNUSED( pRDD );
HB_SYMBOL_UNUSED( ulConnection );
switch( uiIndex )
{
case RDDI_ISDBF:
case RDDI_CANPUTREC:
case RDDI_LOCAL:
case RDDI_REMOTE:
case RDDI_RECORDMAP:
case RDDI_ENCRYPTION:
case RDDI_AUTOLOCK:
case RDDI_STRUCTORD:
case RDDI_LARGEFILE:
case RDDI_MULTITAG:
case RDDI_SORTRECNO:
case RDDI_MULTIKEY:
case RDDI_BLOB_SUPPORT:
hb_itemPutL( pItem, FALSE );
break;
case RDDI_CONNECTION:
case RDDI_TABLETYPE:
case RDDI_MEMOTYPE:
case RDDI_MEMOVERSION:
hb_itemPutNI( pItem, 0 );
break;
case RDDI_STRICTREAD:
fResult = hb_setGetStrictRead();
if( hb_itemType( pItem ) == HB_IT_LOGICAL )
hb_setSetItem( HB_SET_STRICTREAD, pItem );
hb_itemPutL( pItem, fResult );
break;
case RDDI_OPTIMIZE:
fResult = hb_setGetOptimize();
if( hb_itemType( pItem ) == HB_IT_LOGICAL )
hb_setSetItem( HB_SET_OPTIMIZE, pItem );
hb_itemPutL( pItem, fResult );
break;
case RDDI_FORCEOPT:
fResult = hb_setGetForceOpt();
if( hb_itemType( pItem ) == HB_IT_LOGICAL )
hb_setSetItem( HB_SET_FORCEOPT, pItem );
hb_itemPutL( pItem, fResult );
break;
case RDDI_AUTOOPEN:
fResult = hb_setGetAutOpen();
if( hb_itemType( pItem ) == HB_IT_LOGICAL )
hb_setSetItem( HB_SET_AUTOPEN, pItem );
hb_itemPutL( pItem, fResult );
break;
case RDDI_AUTOORDER:
fResult = hb_setGetAutOrder();
if( hb_itemType( pItem ) == HB_IT_LOGICAL )
hb_setSetItem( HB_SET_AUTORDER, pItem );
hb_itemPutL( pItem, fResult );
break;
case RDDI_AUTOSHARE:
fResult = hb_setGetAutoShare();
if( hb_itemType( pItem ) == HB_IT_LOGICAL )
hb_setSetItem( HB_SET_AUTOSHARE, pItem );
hb_itemPutL( pItem, fResult );
break;
case RDDI_LOCKSCHEME:
iResult = hb_setGetDBFLockScheme();
if( hb_itemType( pItem ) & HB_IT_NUMERIC )
hb_setSetItem( HB_SET_DBFLOCKSCHEME, pItem );
hb_itemPutNI( pItem, iResult );
break;
case RDDI_MEMOBLOCKSIZE:
iResult = hb_setGetMBlockSize();
if( hb_itemType( pItem ) & HB_IT_NUMERIC )
hb_setSetItem( HB_SET_MBLOCKSIZE, pItem );
hb_itemPutNI( pItem, iResult );
break;
case RDDI_MEMOEXT:
{
char * szResult = hb_setGetMFileExt();
if( szResult )
szResult = hb_strdup( szResult );
if( hb_itemType( pItem ) & HB_IT_STRING )
{
hb_setSetItem( HB_SET_MFILEEXT, pItem );
if( szResult )
hb_itemPutCLPtr( pItem, szResult, strlen( szResult ) );
else
hb_itemPutC( pItem, NULL );
break;
}
else if( szResult )
{
hb_itemPutCLPtr( pItem, szResult, strlen( szResult ) );
break;
}
/* no break - return FAILURE */
}
case RDDI_TABLEEXT:
case RDDI_ORDBAGEXT:
case RDDI_ORDEREXT:
case RDDI_ORDSTRUCTEXT:
case RDDI_DELIMITER:
case RDDI_SEPARATOR:
case RDDI_TRIGGER:
case RDDI_PENDINGTRIGGER:
hb_itemPutC( pItem, NULL );
/* no break - return FAILURE */
default:
return FAILURE;
}
return SUCCESS;
}
| workarea.c | 1712 |
| STATIC ERRCODE | hb_waUnsupported( AREAP pArea )
static ERRCODE hb_waUnsupported( AREAP pArea )
{
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_waUnsupported(%p)", pArea));
pError = hb_errNew();
hb_errPutGenCode( pError, EG_UNSUPPORTED );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_UNSUPPORTED ) );
SELF_ERROR( pArea, pError );
hb_itemRelease( pError );
return FAILURE;
}
| workarea.c | 1836 |
| STATIC ERRCODE | hb_waRddUnsupported( LPRDDNODE pRDD )
static ERRCODE hb_waRddUnsupported( LPRDDNODE pRDD )
{
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_waRDDUnsupported(%p)", pRDD));
pError = hb_errNew();
hb_errPutGenCode( pError, EG_UNSUPPORTED );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_UNSUPPORTED ) );
hb_errPutSeverity( pError, ES_ERROR );
hb_errPutSubSystem( pError, pRDD->szName );
hb_errLaunch( pError );
hb_itemRelease( pError );
return FAILURE;
}
| workarea.c | 1854 |
| STATIC ERRCODE | hb_waNull( AREAP pArea )
static ERRCODE hb_waNull( AREAP pArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_waNull(%p)", pArea));
HB_SYMBOL_UNUSED( pArea );
return SUCCESS;
}
#endif
/*
* The default virtual method table for all WorkAreas.
*/
static const RDDFUNCS waTable =
{
/* Movement and positioning methods */
/* ( DBENTRYP_BP ) */ hb_waBof, /* Bof */
/* ( DBENTRYP_BP ) */ hb_waEof, /* Eof */
/* ( DBENTRYP_BP ) */ hb_waFound, /* Found */
( DBENTRYP_V ) hb_waUnsupported, /* GoBottom */
( DBENTRYP_UL ) hb_waUnsupported, /* GoTo */
( DBENTRYP_I ) hb_waUnsupported, /* GoToId */
( DBENTRYP_V ) hb_waUnsupported, /* GoTop */
( DBENTRYP_BIB ) hb_waUnsupported, /* Seek */
/* ( DBENTRYP_L ) */ hb_waSkip, /* Skip */
/* ( DBENTRYP_L ) */ hb_waSkipFilter, /* SkipFilter */
( DBENTRYP_L ) hb_waUnsupported, /* SkipRaw */
/* Data management */
/* ( DBENTRYP_VF ) */ hb_waAddField, /* AddField */
( DBENTRYP_B ) hb_waUnsupported, /* Append */
/* ( DBENTRYP_I ) */ hb_waCreateFields, /* CreateFields */
( DBENTRYP_V ) hb_waUnsupported, /* DeleteRec */
( DBENTRYP_BP ) hb_waUnsupported, /* Deleted */
/* ( DBENTRYP_SP ) */ hb_waFieldCount, /* FieldCount */
( DBENTRYP_VF ) hb_waUnsupported, /* FieldDisplay */
/* ( DBENTRYP_SSI ) */ hb_waFieldInfo, /* FieldInfo */
/* ( DBENTRYP_SVP ) */ hb_waFieldName, /* FieldName */
( DBENTRYP_V ) hb_waUnsupported, /* Flush */
( DBENTRYP_PP ) hb_waUnsupported, /* GetRec */
( DBENTRYP_SI ) hb_waUnsupported, /* GetValue */
( DBENTRYP_SVL ) hb_waUnsupported, /* GetVarLen */
( DBENTRYP_V ) hb_waUnsupported, /* GoCold */
( DBENTRYP_V ) hb_waUnsupported, /* GoHot */
( DBENTRYP_P ) hb_waUnsupported, /* PutRec */
( DBENTRYP_SI ) hb_waUnsupported, /* PutValue */
( DBENTRYP_V ) hb_waUnsupported, /* Recall */
( DBENTRYP_ULP ) hb_waUnsupported, /* RecCount */
( DBENTRYP_ISI ) hb_waUnsupported, /* RecInfo */
( DBENTRYP_ULP ) hb_waUnsupported, /* RecNo */
( DBENTRYP_I ) hb_waUnsupported, /* RecId */
/* ( DBENTRYP_S ) */ hb_waSetFieldExtent, /* SetFieldExtent */
/* WorkArea/Database management */
/* ( DBENTRYP_P ) */ hb_waAlias, /* Alias */
/* ( DBENTRYP_V ) */ hb_waClose, /* Close */
/* Like in Clipper map CREATE() method at work area level to OPEN() */
/* ( DBENTRYP_VP ) */ hb_waOpen, /* Create */
/* ( DBENTRYP_SI ) */ hb_waInfo, /* Info */
/* ( DBENTRYP_V ) */ hb_waNewArea, /* NewArea */
/* ( DBENTRYP_VP ) */ hb_waOpen, /* Open */
/* ( DBENTRYP_V ) */ hb_waRelease, /* Release */
/* ( DBENTRYP_SP ) */ hb_waStructSize, /* StructSize */
/* ( DBENTRYP_P ) */ hb_waSysName, /* SysName */
/* ( DBENTRYP_VEI ) */ hb_waEval, /* Eval */
( DBENTRYP_V ) hb_waUnsupported, /* Pack */
( DBENTRYP_LSP ) hb_waUnsupported, /* PackRec */
( DBENTRYP_VS ) hb_waUnsupported, /* Sort */
/* ( DBENTRYP_VT ) */ hb_waTrans, /* Trans */
/* ( DBENTRYP_VT ) */ hb_waTransRec, /* TransRec */
( DBENTRYP_V ) hb_waUnsupported, /* Zap */
/* Relational Methods */
/* ( DBENTRYP_VR ) */ hb_waChildEnd, /* ChildEnd */
/* ( DBENTRYP_VR ) */ hb_waChildStart, /* ChildStart */
( DBENTRYP_VR ) hb_waUnsupported, /* ChildSync */
/* ( DBENTRYP_V ) */ hb_waSyncChildren, /* SyncChildren */
/* ( DBENTRYP_V ) */ hb_waClearRel, /* ClearRel */
( DBENTRYP_V ) hb_waUnsupported, /* ForceRel */
/* ( DBENTRYP_SVP ) */ hb_waRelArea, /* RelArea */
/* ( DBENTRYP_VR ) */ hb_waRelEval, /* RelEval */
/* ( DBENTRYP_SI ) */ hb_waRelText, /* RelText */
/* ( DBENTRYP_VR ) */ hb_waSetRel, /* SetRel */
/* Order Management */
( DBENTRYP_OI ) hb_waUnsupported, /* OrderListAdd */
( DBENTRYP_V ) hb_waUnsupported, /* OrderListClear */
( DBENTRYP_OI ) hb_waUnsupported, /* OrderListDelete */
( DBENTRYP_OI ) hb_waUnsupported, /* OrderListFocus */
( DBENTRYP_V ) hb_waUnsupported, /* OrderListRebuild */
/* ( DBENTRYP_VOI ) */ hb_waOrderCondition, /* OrderCondition */
( DBENTRYP_VOC ) hb_waUnsupported, /* OrderCreate */
( DBENTRYP_OI ) hb_waUnsupported, /* OrderDestroy */
/* ( DBENTRYP_OII ) */ hb_waOrderInfo, /* OrderInfo */
/* Filters and Scope Settings */
/* ( DBENTRYP_V ) */ hb_waClearFilter, /* ClearFilter */
/* ( DBENTRYP_V ) */ hb_waClearLocate, /* ClearLocate */
( DBENTRYP_V ) hb_waUnsupported, /* ClearScope */
( DBENTRYP_VPLP ) hb_waUnsupported, /* CountScope */
/* ( DBENTRYP_I ) */ hb_waFilterText, /* FilterText */
( DBENTRYP_SI ) hb_waUnsupported, /* ScopeInfo */
/* ( DBENTRYP_VFI ) */ hb_waSetFilter, /* SetFilter */
/* ( DBENTRYP_VLO ) */ hb_waSetLocate, /* SetLocate */
( DBENTRYP_VOS ) hb_waUnsupported, /* SetScope */
( DBENTRYP_VPL ) hb_waUnsupported, /* SkipScope */
/* ( DBENTRYP_B ) */ hb_waLocate, /* Locate */
/* Miscellaneous */
/* ( DBENTRYP_P ) */ hb_waCompile, /* Compile */
/* ( DBENTRYP_I ) */ hb_waError, /* Error */
/* ( DBENTRYP_I ) */ hb_waEvalBlock, /* EvalBlock */
/* Network operations */
( DBENTRYP_VSP ) hb_waUnsupported, /* RawLock */
( DBENTRYP_VL ) hb_waUnsupported, /* Lock */
( DBENTRYP_I ) hb_waUnsupported, /* UnLock */
/* Memofile functions */
( DBENTRYP_V ) hb_waUnsupported, /* CloseMemFile */
( DBENTRYP_VP ) hb_waUnsupported, /* CreateMemFile */
( DBENTRYP_SVPB ) hb_waUnsupported, /* GetValueFile */
( DBENTRYP_VP ) hb_waUnsupported, /* OpenMemFile */
( DBENTRYP_SVPB ) hb_waUnsupported, /* PutValueFile */
/* Database file header handling */
( DBENTRYP_V ) hb_waUnsupported, /* ReadDBHeader */
( DBENTRYP_V ) hb_waUnsupported, /* WriteDBHeader */
/* non WorkArea functions */
( DBENTRYP_R ) NULL, /* Init */
( DBENTRYP_R ) NULL, /* Exit */
( DBENTRYP_RVVL ) hb_waRddUnsupported, /* Drop */
( DBENTRYP_RVVL ) hb_waRddUnsupported, /* Exists */
/* ( DBENTRYP_RSLV ) */ hb_waRddInfo, /* RddInfo */
/* Special and reserved methods */
( DBENTRYP_SVP ) hb_waUnsupported /* WhoCares */
};
#define HB_RDD_POOL_ALLOCSIZE 128
/* common for all threads list of registered RDDs */
static HB_CRITICAL_NEW( s_rddMtx );
static LPRDDNODE * s_RddList = NULL; /* Registered RDDs pool */
static USHORT s_uiRddMax = 0; /* Size of RDD pool */
static USHORT s_uiRddCount = 0; /* Number of registered RDD */
| workarea.c | 1876 |
| HB_EXPORT LPRDDNODE | hb_rddGetNode( USHORT uiNode )
HB_EXPORT LPRDDNODE hb_rddGetNode( USHORT uiNode )
{
HB_TRACE(HB_TR_DEBUG, ("hb_rddGetNode(%hu)", uiNode));
return uiNode < s_uiRddCount ? s_RddList[ uiNode ] : NULL;
}
| workarea.c | 2026 |
| HB_EXPORT PHB_ITEM | hb_rddList( USHORT uiType )
HB_EXPORT PHB_ITEM hb_rddList( USHORT uiType )
{
USHORT uiCount, uiIndex, uiRdds;
PHB_ITEM pRddArray;
LPRDDNODE pNode;
HB_TRACE(HB_TR_DEBUG, ("hb_rddList(%hu)", uiType));
for( uiCount = uiRdds = 0; uiCount < s_uiRddCount; ++uiCount )
{
if( uiType == 0 || s_RddList[ uiCount ]->uiType == uiType )
++uiRdds;
}
pRddArray = hb_itemArrayNew( uiRdds );
for( uiCount = uiIndex = 0; uiCount < s_uiRddCount && uiIndex < uiRdds; ++uiCount )
{
pNode = s_RddList[ uiCount ];
if( uiType == 0 || pNode->uiType == uiType )
hb_arraySetC( pRddArray, ++uiIndex, pNode->szName );
}
return pRddArray;
}
| workarea.c | 2036 |
| HB_EXPORT LPRDDNODE | hb_rddFindNode( const char * szDriver, USHORT * uiIndex )
HB_EXPORT LPRDDNODE hb_rddFindNode( const char * szDriver, USHORT * uiIndex )
{
USHORT uiCount;
HB_TRACE(HB_TR_DEBUG, ("hb_rddFindNode(%s, %p)", szDriver, uiIndex));
for( uiCount = 0; uiCount < s_uiRddCount; uiCount++ )
{
LPRDDNODE pNode = s_RddList[ uiCount ];
if( strcmp( pNode->szName, szDriver ) == 0 ) /* Matched RDD */
{
if( uiIndex )
* uiIndex = uiCount;
return pNode;
}
}
if( uiIndex )
* uiIndex = 0;
return NULL;
}
| workarea.c | 2059 |
| HB_EXPORT VOID | hb_rddShutDown( void )
HB_EXPORT void hb_rddShutDown( void )
{
USHORT uiCount;
HB_TRACE(HB_TR_DEBUG, ("hb_rddShutDown()"));
hb_rddCloseDetachedAreas();
if( s_uiRddCount > 0 )
{
for( uiCount = 0; uiCount < s_uiRddCount; uiCount++ )
{
if( s_RddList[ uiCount ]->pTable.exit != NULL )
{
SELF_EXIT( s_RddList[ uiCount ] );
}
hb_xfree( s_RddList[ uiCount ] );
}
hb_xfree( s_RddList );
s_RddList = NULL;
s_uiRddMax = s_uiRddCount = 0;
}
}
| workarea.c | 2083 |
| HB_EXPORT INT | hb_rddRegister( const char * szDriver, USHORT uiType )
HB_EXPORT int hb_rddRegister( const char * szDriver, USHORT uiType )
{
LPRDDNODE pRddNewNode;
PHB_DYNS pGetFuncTable;
char szGetFuncTable[ HB_RDD_MAX_DRIVERNAME_LEN + 14 ];
USHORT uiFunctions;
int iResult;
HB_TRACE(HB_TR_DEBUG, ("hb_rddRegister(%s, %hu)", szDriver, uiType));
if( hb_rddFindNode( szDriver, NULL ) ) /* Duplicated RDD */
return 1;
snprintf( szGetFuncTable, sizeof( szGetFuncTable ), "%s_GETFUNCTABLE",
szDriver );
pGetFuncTable = hb_dynsymFindName( szGetFuncTable );
if( !pGetFuncTable )
return 2; /* Not valid RDD */
/* Create a new RDD node */
pRddNewNode = ( LPRDDNODE ) hb_xgrab( sizeof( RDDNODE ) );
memset( pRddNewNode, 0, sizeof( RDDNODE ) );
/* Fill the new RDD node */
hb_strncpy( pRddNewNode->szName, szDriver, sizeof( pRddNewNode->szName ) - 1 );
pRddNewNode->uiType = uiType;
pRddNewNode->rddID = s_uiRddCount;
/* Call _GETFUNCTABLE() */
hb_vmPushDynSym( pGetFuncTable );
hb_vmPushNil();
hb_vmPushPointer( ( void * ) &uiFunctions );
hb_vmPushPointer( ( void * ) &pRddNewNode->pTable );
hb_vmPushPointer( ( void * ) &pRddNewNode->pSuperTable );
hb_vmPushInteger( s_uiRddCount );
hb_vmDo( 4 );
if( hb_parni( -1 ) != SUCCESS )
iResult = 3; /* Invalid FUNCTABLE */
else
{
hb_threadEnterCriticalSection( &s_rddMtx );
/* repeat the test to protect against possible registering RDD by
* _GETFUNCTABLE()
*/
if( ! hb_rddFindNode( szDriver, NULL ) ) /* Duplicated RDD */
{
if( s_uiRddCount == s_uiRddMax )
{
s_uiRddMax += HB_RDD_POOL_ALLOCSIZE;
s_RddList = ( LPRDDNODE * )
hb_xrealloc( s_RddList, sizeof( LPRDDNODE ) * s_uiRddMax );
}
s_RddList[ s_uiRddCount ] = pRddNewNode; /* Add the new RDD node */
s_uiRddCount++;
iResult = 0;
}
else
iResult = 1;
hb_threadLeaveCriticalSection( &s_rddMtx );
}
if( iResult != 0 )
hb_xfree( pRddNewNode );
else if( pRddNewNode->pTable.init != NULL )
SELF_INIT( pRddNewNode );
return iResult;
}
| workarea.c | 2110 |
| HB_EXPORT ERRCODE | hb_rddInherit( RDDFUNCS * pTable, const RDDFUNCS * pSubTable, RDDFUNCS * pSuperTable, const char * szDrvName )
HB_EXPORT ERRCODE hb_rddInherit( RDDFUNCS * pTable, const RDDFUNCS * pSubTable, RDDFUNCS * pSuperTable, const char * szDrvName )
{
LPRDDNODE pRddNode;
USHORT uiCount;
DBENTRYP_V * pFunction, * pSubFunction;
HB_TRACE(HB_TR_DEBUG, ("hb_rddInherit(%p, %p, %p, %s)", pTable, pSubTable, pSuperTable, szDrvName));
if( !pTable )
{
return FAILURE;
}
/* Copy the pSuperTable into pTable */
if( !szDrvName || ! *szDrvName )
{
/* no name for inherited driver - use the default one */
memcpy( pTable, &waTable, sizeof( RDDFUNCS ) );
memcpy( pSuperTable, &waTable, sizeof( RDDFUNCS ) );
}
else
{
char szSuperName[ HB_RDD_MAX_DRIVERNAME_LEN + 1 ];
hb_strncpyUpper( szSuperName, szDrvName, sizeof( szSuperName ) - 1 );
pRddNode = hb_rddFindNode( szSuperName, NULL );
if( !pRddNode )
{
return FAILURE;
}
memcpy( pTable, &pRddNode->pTable, sizeof( RDDFUNCS ) );
memcpy( pSuperTable, &pRddNode->pTable, sizeof( RDDFUNCS ) );
}
/* Copy the non NULL entries from pSubTable into pTable */
pFunction = ( DBENTRYP_V * ) pTable;
pSubFunction = ( DBENTRYP_V * ) pSubTable;
for( uiCount = 0; uiCount < RDDFUNCSCOUNT; uiCount++ )
{
if( * pSubFunction )
* pFunction = * pSubFunction;
pFunction ++;
pSubFunction ++;
}
return SUCCESS;
}
| workarea.c | 2182 |
| HB_FUNC | __RDDPREALLOCATE(void)
HB_FUNC( __RDDPREALLOCATE )
{
LONG lNewSize = hb_parnl( 1 );
if( lNewSize > ( LONG ) USHRT_MAX )
lNewSize = USHRT_MAX;
if( lNewSize > ( LONG ) s_uiRddMax )
{
s_uiRddMax += HB_RDD_POOL_ALLOCSIZE;
s_RddList = ( LPRDDNODE * )
hb_xrealloc( s_RddList, sizeof( LPRDDNODE ) * s_uiRddMax );
}
hb_retnl( s_uiRddMax );
}
HB_FUNC_EXTERN( RDDSYS );
| workarea.c | 2236 |
| VOID | _hb_rddWorkAreaForceLink( void )
void _hb_rddWorkAreaForceLink( void )
{
HB_FUNC_EXEC( RDDSYS );
}
| workarea.c | 2258 |
| dbdelim.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __dbDelim( lExport, cFile, cDelimArg, aFields, bFor, bWhile, nNext, nRecord, lRest )
FUNCTION __dbDelim( lExport, cFile, cDelimArg, aFields, bFor, bWhile, nNext, nRecord, lRest )
#ifdef HB_C52_STRICT
LOCAL nSrcArea
LOCAL nDstArea
LOCAL aStruct
LOCAL cRDD := "DELIM"
IF lExport
nSrcArea := Select()
ELSE
nDstArea := Select()
ENDIF
IF Empty( aStruct := __dbStructFilter( dbStruct(), aFields ) )
RETURN .F.
ENDIF
IF lExport
dbCreate( cFile, aStruct, cRDD, .T., "", cDelimArg )
nDstArea := Select()
IF nDstArea == nSrcArea
nDstArea := NIL
ENDIF
dbSelectArea( nSrcArea )
ELSE
IF !__dbOpenSDF( cFile, aStruct, cRDD, .T., "", cDelimArg )
RETURN .F.
ENDIF
nSrcArea := Select()
ENDIF
IF nDstArea != NIL
__dbTrans( nDstArea, aStruct, bFor, bWhile, nNext, nRecord, lRest )
ENDIF
IF lExport
IF nDstArea != NIL
dbSelectArea( nDstArea )
dbCloseArea()
ENDIF
dbSelectArea( nSrcArea )
ELSE
dbSelectArea( nSrcArea )
dbCloseArea()
dbSelectArea( nDstArea )
ENDIF
RETURN .T.
#else
RETURN iif( lExport,;
__dbCopy( cFile, aFields, bFor, bWhile, nNext, nRecord, lRest, "DELIM", , , cDelimArg ) ,;
__dbApp( cFile, aFields, bFor, bWhile, nNext, nRecord, lRest, "DELIM", , , cDelimArg ) )
| dbdelim.prg | 61 |
| dbfuncs.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | dbClearFil()
FUNCTION dbClearFil()
RETURN dbClearFilter()
| dbfuncs.prg | 55 |
| FUNCTION | dbSetDrive( cRDD )
FUNCTION dbSetDrive( cRDD )
RETURN dbSetDriver( cRDD )
| dbfuncs.prg | 58 |
| FUNCTION | dbSetRelat( xArea, bRelation, cRelation, lScoped )
FUNCTION dbSetRelat( xArea, bRelation, cRelation, lScoped )
RETURN dbSetRelation( xArea, bRelation, cRelation, lScoped )
| dbfuncs.prg | 61 |
| FUNCTION | dbRLockLis()
FUNCTION dbRLockLis()
RETURN dbRLockList()
| dbfuncs.prg | 64 |
| FUNCTION | dbCloseAre()
FUNCTION dbCloseAre()
RETURN dbCloseArea()
| dbfuncs.prg | 67 |
| FUNCTION | dbSelectAr( xArea )
FUNCTION dbSelectAr( xArea )
RETURN dbSelectArea( xArea )
| dbfuncs.prg | 70 |
| FUNCTION | dbUnLockAl()
FUNCTION dbUnLockAl()
RETURN dbUnLockAll()
| dbfuncs.prg | 73 |
| FUNCTION | dbClearRel()
FUNCTION dbClearRel()
RETURN dbClearRelation()
| dbfuncs.prg | 76 |
| FUNCTION | dbSetFilte( bFilter, cFilter )
FUNCTION dbSetFilte( bFilter, cFilter )
RETURN dbSetFilter( bFilter, cFilter )
| dbfuncs.prg | 79 |
| FUNCTION | dbFieldInf( nType, nArea, xInfo )
FUNCTION dbFieldInf( nType, nArea, xInfo )
RETURN dbFieldInfo( nType, nArea, xInfo )
| dbfuncs.prg | 82 |
| FUNCTION | dbOrderInf( nInfo, cIndex, xOrder, xSet )
FUNCTION dbOrderInf( nInfo, cIndex, xOrder, xSet )
RETURN dbOrderInfo( nInfo, cIndex, xOrder, xSet )
| dbfuncs.prg | 85 |
| FUNCTION | dbRecordIn( nInfo, nRecord, xSet )
FUNCTION dbRecordIn( nInfo, nRecord, xSet )
RETURN dbRecordInfo( nInfo, nRecord, xSet )
| dbfuncs.prg | 88 |
| FUNCTION | rddSetDefa( cRDD )
FUNCTION rddSetDefa( cRDD )
RETURN rddSetDefault( cRDD )
| dbfuncs.prg | 91 |
| FUNCTION | __dbCopySt( cFileName, aFieldList )
FUNCTION __dbCopySt( cFileName, aFieldList )
RETURN __dbCopyStruct( cFileName, aFieldList )
| dbfuncs.prg | 94 |
| FUNCTION | __dbCopyXS( cFileName )
FUNCTION __dbCopyXS( cFileName )
RETURN __dbCopyXStruct( cFileName )
| dbfuncs.prg | 97 |
| FUNCTION | __dbOpenSD( cFile, aStruct, cRDD, lOpenMode, cAlias, cDelimArg, cCodePage, nConnection )
FUNCTION __dbOpenSD( cFile, aStruct, cRDD, lOpenMode, cAlias, cDelimArg, cCodePage, nConnection )
RETURN __dbOpenSDF( cFile, aStruct, cRDD, lOpenMode, cAlias, cDelimArg, cCodePage, nConnection )
| dbfuncs.prg | 105 |
| FUNCTION | __dbArrang( nToArea, aStruct, bFor, bWhile, nNext, nRecord, lRest, aFields )
FUNCTION __dbArrang( nToArea, aStruct, bFor, bWhile, nNext, nRecord, lRest, aFields )
RETURN __dbArrange( nToArea, aStruct, bFor, bWhile, nNext, nRecord, lRest, aFields )
| dbfuncs.prg | 108 |
| FUNCTION | ordListCle()
FUNCTION ordListCle()
RETURN ordListClear()
| dbfuncs.prg | 111 |
| FUNCTION | ordListReb()
FUNCTION ordListReb()
RETURN ordListRebuild()
| dbfuncs.prg | 114 |
| FUNCTION | ordSetFocu( xOrder, cFile )
FUNCTION ordSetFocu( xOrder, cFile )
RETURN ordSetFocus( xOrder, cFile )
| dbfuncs.prg | 117 |
| FUNCTION | ordSetRela( xArea, bRelation, cRelation )
FUNCTION ordSetRela( xArea, bRelation, cRelation )
RETURN ordSetRelation( xArea, bRelation, cRelation )
| dbfuncs.prg | 120 |
| dbfuncsx.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | _dbExport( cFile, aFields, bFor, bWhile, nNext, nRecord, lRest, cXPP_Driver, cDelimiter )
FUNCTION _dbExport( cFile, aFields, bFor, bWhile, nNext, nRecord, lRest, cXPP_Driver, cDelimiter )
DO CASE
CASE cXPP_Driver == "SDFDBE"
RETURN __dbCopy( cFile, aFields, bFor, bWhile, nNext, nRecord, lRest, "SDF" )
/* Alternate CA-Cl*pper compatible call:
RETURN __dbSDF( .T., cFile, aFields, bFor, bWhile, nNext, nRecord, lRest ) */
CASE cXPP_Driver == "DELDBE"
RETURN __dbCopy( cFile, aFields, bFor, bWhile, nNext, nRecord, lRest, "DELIM", , , cDelimiter )
/* Alternate CA-Cl*pper compatible call:
RETURN __dbDelim( .T., cFile, cDelimiter, aFields, bFor, bWhile, nNext, nRecord, lRest ) */
ENDCASE
RETURN __dbCopy( cFile, aFields, bFor, bWhile, nNext, nRecord, lRest, cXPP_Driver )
| dbfuncsx.prg | 55 |
| dbjoin.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __dbJoin( cAlias, cFile, aFields, bFor, cRDD, nConnection, cCodePage )
FUNCTION __dbJoin( cAlias, cFile, aFields, bFor, cRDD, nConnection, cCodePage )
LOCAL nMaster := Select()
LOCAL nDetail := Select( cAlias )
LOCAL nResult
LOCAL aStruct
LOCAL aJoinList
LOCAL oError
LOCAL lError := .F.
dbSelectArea( nMaster )
IF Empty( aStruct := __FieldTwo( cAlias, aFields ) )
RETURN .F.
ENDIF
BEGIN SEQUENCE
dbCreate( cFile, aStruct, cRDD, .T., "", NIL, cCodePage, nConnection )
nResult := Select()
aJoinList := __JoinList( nMaster, nDetail, nResult, aStruct )
dbSelectArea( nMaster )
dbGoTop()
DO WHILE !Eof()
dbSelectArea( nDetail )
dbGoTop()
DO WHILE !Eof()
dbSelectArea( nMaster )
IF Eval( bFor )
__doJoinList( aJoinList )
ENDIF
dbSelectArea( nDetail )
dbSkip()
ENDDO
dbSelectArea( nMaster )
dbSkip()
ENDDO
RECOVER USING oError
lError := .T.
END SEQUENCE
IF nResult != NIL
dbSelectArea( nResult )
dbCloseArea()
ENDIF
dbSelectArea( nMaster )
IF lError
Break( oError )
ENDIF
RETURN .T.
| dbjoin.prg | 58 |
| STATIC FUNCTION | __FieldTwo( cAlias, aFields )
STATIC FUNCTION __FieldTwo( cAlias, aFields )
LOCAL aFldTemp
LOCAL bFind
LOCAL aStruct
LOCAL cField
IF Empty( aFields )
RETURN dbStruct()
ENDIF
aFldTemp := {}
AEval( aFields, {| cFld | AAdd( aFldTemp, Trim( Upper( cFld ) ) ) } )
aFields := aFldTemp
aStruct := {}
bFind := {| cFld | cFld == cField }
AEval( dbStruct(), {| aFld | cField := aFld[ DBS_NAME ],;
iif( AScan( aFields, bFind ) == 0, NIL, AAdd( aStruct, aFld ) ) } )
Select( cAlias )
bFind := {| cFld | "->" $ cFld .AND. SubStr( cFld, At( "->", cFld ) + 2 ) == cField }
AEval( dbStruct(), {| aFld | cField := aFld[ DBS_NAME ],;
iif( AScan( aFields, bFind ) == 0, NIL, AAdd( aStruct, aFld ) ) } )
RETURN aStruct
| dbjoin.prg | 117 |
| STATIC FUNCTION | __JoinList( nMaster, nDetail, nResult, aStruct )
STATIC FUNCTION __JoinList( nMaster, nDetail, nResult, aStruct )
LOCAL aList := {}
LOCAL nPos
LOCAL i
FOR i := 1 TO Len( aStruct )
IF ( nPos := ( nMaster )->( FieldPos( aStruct[ i ][ DBS_NAME ] ) ) ) != 0
AAdd( aList, { nResult, nMaster, nPos, i } )
ELSEIF ( nPos := ( nDetail )->( FieldPos( aStruct[ i ][ DBS_NAME ] ) ) ) != 0
AAdd( aList, { nResult, nDetail, nPos, i } )
ENDIF
NEXT
RETURN aList
| dbjoin.prg | 144 |
| STATIC PROCEDURE | __doJoinList( aList )
STATIC PROCEDURE __doJoinList( aList )
LOCAL aJoin
IF Len( aList ) > 0
( aList[ 1 ][ 1 ] )->( dbAppend() )
FOR EACH aJoin IN aList
( aJoin[ 1 ] )->( FieldPut( aJoin[ 4 ], ( aJoin[ 2 ] )->( FieldGet( aJoin[ 3 ] ) ) ) )
NEXT
ENDIF
RETURN
| dbjoin.prg | 159 |
| dbjoinx.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | dbJoin( cAlias, cFile, aFields, bFor )
FUNCTION dbJoin( cAlias, cFile, aFields, bFor )
RETURN __dbJoin( cAlias, cFile, aFields, bFor )
| dbjoinx.prg | 55 |
| dblist.prg |
| Type | Function | Source | Line |
|---|
| PROCEDURE | __dbList( lOff, abEval, lAll, bFor, bWhile, nNext, nRecord, lRest, lToPrint, cToFileName )
PROCEDURE __dbList( lOff, abEval, lAll, bFor, bWhile, nNext, nRecord, lRest, lToPrint, cToFileName )
LOCAL lOldPrinter
LOCAL lOldExtra
LOCAL cOldExtraFile
LOCAL cPath
LOCAL cName
LOCAL cExt
LOCAL oError
LOCAL lError := .F.
LOCAL bOutBlock
/* Choose the output style */
IF lOff
bOutBlock := {|| QOut( iif( Deleted(), "*", " " ) ),;
AEval( abEval, {| bEval | QQOut( Eval( bEval ), "" ) } ) }
ELSE
bOutBlock := {|| QOut( Str( RecNo(), 7 ), iif( Deleted(), "*", " " ) ),;
AEval( abEval, {| bEval | QQOut( Eval( bEval ), "" ) } ) }
ENDIF
/* Save SETs */
IF !Empty( lToPrint )
lOldPrinter := Set( _SET_PRINTER, .T. )
ENDIF
IF !Empty( cToFileName )
hb_FNameSplit( cToFileName, @cPath, @cName, @cExt )
IF Set( _SET_DEFEXTENSIONS ) .AND. Empty( cExt )
cExt := ".txt"
ENDIF
lOldExtra := Set( _SET_EXTRA, .T. )
cOldExtraFile := Set( _SET_EXTRAFILE, hb_FNameMerge( cPath, cName, cExt ) )
ENDIF
/* Do the job */
BEGIN SEQUENCE
IF Empty( lAll ) .AND. ;
Empty( bFor ) .AND. ;
Empty( bWhile ) .AND. ;
Empty( nNext ) .AND. ;
Empty( nRecord ) .AND. ;
Empty( lRest )
Eval( bOutBlock )
ELSE
dbEval( bOutBlock, bFor, bWhile, nNext, nRecord, lRest )
ENDIF
RECOVER USING oError
lError := .T.
END SEQUENCE
/* Restore SETs */
IF !Empty( lToPrint )
Set( _SET_PRINTER, lOldPrinter )
ENDIF
IF !Empty( cToFileName )
Set( _SET_EXTRAFILE, cOldExtraFile )
Set( _SET_EXTRA, lOldExtra )
ENDIF
/* On error signal the error for the higher level error handler or quit */
IF lError
Break( oError )
ENDIF
RETURN
| dblist.prg | 55 |
| dblistx.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | dbList( lOff, abEval, lAll, bFor, bWhile, nNext, nRecord, lRest, lToPrint, cToFileName )
FUNCTION dbList( lOff, abEval, lAll, bFor, bWhile, nNext, nRecord, lRest, lToPrint, cToFileName )
RETURN __dbList( abEval, lOff, lAll, bFor, bWhile, nNext, nRecord, lRest, lToPrint, cToFileName )
| dblistx.prg | 55 |
| dbsdf.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __dbSDF( lExport, cFile, aFields, bFor, bWhile, nNext, nRecord, lRest )
FUNCTION __dbSDF( lExport, cFile, aFields, bFor, bWhile, nNext, nRecord, lRest )
RETURN iif( lExport,;
__dbCopy( cFile, aFields, bFor, bWhile, nNext, nRecord, lRest, "SDF" ) ,;
__dbApp( cFile, aFields, bFor, bWhile, nNext, nRecord, lRest, "SDF" ) )
| dbsdf.prg | 60 |
| dbsort.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __dbSort( cToFileName, aFields, bFor, bWhile, nNext, nRecord, lRest, cRDD, nConnection, cCodePage )
FUNCTION __dbSort( cToFileName, aFields, bFor, bWhile, nNext, nRecord, lRest,;
cRDD, nConnection, cCodePage )
LOCAL nOldArea
LOCAL nToArea
LOCAL aStruct
LOCAL oError
LOCAL lError := .F.
IF Empty( aStruct := dbStruct() )
RETURN .F.
ENDIF
nOldArea := Select()
BEGIN SEQUENCE
dbCreate( cToFileName, aStruct, cRDD, .T., "", NIL, cCodePage, nConnection )
nToArea := Select()
dbSelectArea( nOldArea )
__dbArrange( nToArea, aStruct, bFor, bWhile, nNext, nRecord, lRest, aFields )
RECOVER USING oError
lError := .T.
END SEQUENCE
IF nToArea != NIL
dbSelectArea( nToArea )
dbCloseArea()
ENDIF
dbSelectArea( nOldArea )
IF lError
Break( oError )
ENDIF
RETURN .T.
| dbsort.prg | 56 |
| dbsortx.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | dbSort( cToFileName, aFields, bFor, bWhile, nNext, nRecord, lRest )
FUNCTION dbSort( cToFileName, aFields, bFor, bWhile, nNext, nRecord, lRest )
RETURN __dbSort( cToFileName, aFields, bFor, bWhile, nNext, nRecord, lRest )
| dbsortx.prg | 55 |
| dbstrux.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __dbCopyStruct( cFileName, aFieldList )
FUNCTION __dbCopyStruct( cFileName, aFieldList )
RETURN dbCreate( cFileName, __dbStructFilter( dbStruct(), aFieldList ) )
| dbstrux.prg | 56 |
| FUNCTION | __dbCopyXStruct( cFileName )
FUNCTION __dbCopyXStruct( cFileName )
LOCAL nOldArea
LOCAL aStruct
LOCAL oError
LOCAL lError := .F.
IF Empty( aStruct := dbStruct() )
RETURN .F.
ENDIF
nOldArea := Select()
BEGIN SEQUENCE
dbSelectArea( 0 )
__dbCreate( cFileName, NIL, NIL, .F., NIL )
AEval( aStruct, {| aField | iif( aField[ DBS_TYPE ] == "C" .AND. aField[ DBS_LEN ] > 255,;
( aField[ DBS_DEC ] := Int( aField[ DBS_LEN ] / 256 ), aField[ DBS_LEN ] := aField[ DBS_LEN ] % 256 ), ),;
dbAppend(),;
FIELD->FIELD_NAME := aField[ DBS_NAME ],;
FIELD->FIELD_TYPE := aField[ DBS_TYPE ],;
FIELD->FIELD_LEN := aField[ DBS_LEN ],;
FIELD->FIELD_DEC := aField[ DBS_DEC ] } )
/* NOTE: CA-Cl*pper has a bug, where only a plain RECOVER statement is
used here (without the USING keyword), so oError will always be NIL. */
RECOVER USING oError
lError := .T.
END SEQUENCE
IF Select() != nOldArea
dbCloseArea()
dbSelectArea( nOldArea )
ENDIF
IF lError
Break( oError )
ENDIF
RETURN .T.
| dbstrux.prg | 59 |
| FUNCTION | __dbCreate( cFileName, cFileFrom, cRDD, lNew, cAlias, cCodePage, nConnection )
FUNCTION __dbCreate( cFileName, cFileFrom, cRDD, lNew, cAlias, cCodePage, nConnection )
LOCAL nOldArea := Select()
LOCAL aStruct := {}
LOCAL oError
DEFAULT lNew TO .F.
IF cAlias == NIL
hb_FNameSplit( cFileName, NIL, @cAlias )
ENDIF
IF Used() .AND. !lNew
dbCloseArea()
ENDIF
BEGIN SEQUENCE
IF Empty( cFileFrom )
dbCreate( cFileName, { { "FIELD_NAME", "C", 10, 0 },;
{ "FIELD_TYPE", "C", 1, 0 },;
{ "FIELD_LEN" , "N", 3, 0 },;
{ "FIELD_DEC" , "N", 3, 0 } },;
cRDD, .F., cAlias, NIL, cCodePage, nConnection )
ELSE
dbUseArea( lNew, NIL, cFileFrom, "" )
dbEval( {|| AAdd( aStruct, { FIELD->FIELD_NAME ,;
FIELD->FIELD_TYPE ,;
FIELD->FIELD_LEN ,;
FIELD->FIELD_DEC } ) } )
dbCloseArea()
IF lNew
dbSelectArea( nOldArea )
ENDIF
/* Type detection is more in sync with dbCreate() logic in Harbour, as lowercase "C"
and padded/continued strings ("C ", "C...") are also accepted. */
AEval( aStruct, {| aField | iif( Upper( Left( aField[ DBS_TYPE ], 1 ) ) == "C" .AND. aField[ DBS_DEC ] != 0,;
( aField[ DBS_LEN ] += aField[ DBS_DEC ] * 256,;
aField[ DBS_DEC ] := 0 ), NIL ) } )
dbCreate( cFileName, aStruct, cRDD, lNew, cAlias, NIL, cCodePage, nConnection )
ENDIF
RECOVER USING oError
dbCloseArea()
Break( oError )
END SEQUENCE
RETURN Used()
| dbstrux.prg | 105 |
| FUNCTION | __dbStructFilter( aStruct, aFieldList )
FUNCTION __dbStructFilter( aStruct, aFieldList )
LOCAL aStructFiltered
LOCAL bFindName
LOCAL cName
IF Empty( aFieldList )
RETURN aStruct
ENDIF
/* Build a filtered list of the requested fields. */
aStructFiltered := {}
bFindName := {| aField | aField[ DBS_NAME ] == cName }
AEval( aFieldList, {| cFieldName, nIndex | ;
cName := RTrim( Upper( cFieldName ) ),;
nIndex := AScan( aStruct, bFindName ),;
iif( nIndex == 0, NIL, AAdd( aStructFiltered, aStruct[ nIndex] ) ) } )
RETURN aStructFiltered
| dbstrux.prg | 163 |
| dbstruxu.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __FLEDIT( aStruct, aFieldList )
FUNCTION __FLEDIT( aStruct, aFieldList )
RETURN __dbStructFilter( aStruct, aFieldList )
| dbstruxu.prg | 59 |
| dbstruxx.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | dbCopyStruct( cFileName, aFieldList )
FUNCTION dbCopyStruct( cFileName, aFieldList )
RETURN dbCreate( cFileName, __dbStructFilter( dbStruct(), aFieldList ) )
| dbstruxx.prg | 57 |
| FUNCTION | dbCopyExtStruct( cFileName )
FUNCTION dbCopyExtStruct( cFileName )
RETURN __dbCopyXStruct( cFileName )
| dbstruxx.prg | 60 |
| dbtotal.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __dbTotal( cFile, xKey, aFields, xFor, xWhile, nNext, nRec, lRest, cRDD, nConnection, cCodePage )
FUNCTION __dbTotal( cFile, xKey, aFields,;
xFor, xWhile, nNext, nRec, lRest,;
cRDD, nConnection, cCodePage )
LOCAL nOldArea
LOCAL nNewArea
LOCAL aNewDbStruct
LOCAL aGetField
LOCAL aFieldsSum
LOCAL lDbTransRecord
LOCAL xCurKey
LOCAL bWhileBlock
LOCAL bForBlock
LOCAL bKeyBlock
LOCAL oError
LOCAL lError := .F.
IF ISCHARACTER( xWhile )
bWhileBlock := &("{||" + xWhile + "}")
lRest := .T.
ELSEIF ISBLOCK( xWhile )
bWhileBlock := xWhile
lRest := .T.
ELSE
bWhileBlock := {|| .T. }
ENDIF
IF ISCHARACTER( xFor )
bForBlock := &("{||" + xFor + "}")
ELSEIF ISBLOCK( xFor )
bForBlock := xFor
ELSE
bForBlock := {|| .T. }
ENDIF
DEFAULT lRest TO .F.
IF nRec != NIL
dbGoto( nRec )
nNext := 1
ELSE
IF nNext == NIL
nNext := -1
IF !lRest
dbGoTop()
ENDIF
ELSE
lRest := .T.
ENDIF
ENDIF
nOldArea := Select()
aNewDbStruct := {}
AEval( dbStruct(), {| aField | iif( aField[ DBS_TYPE ] == "M", NIL, AAdd( aNewDbStruct, aField ) ) } )
IF Empty( aNewDbStruct )
RETURN .F.
ENDIF
BEGIN SEQUENCE
IF Empty( xKey )
xKey := ordKey()
ENDIF
IF ISCHARACTER( xKey )
bKeyBlock := &("{||" + xKey + "}")
ELSEIF ISBLOCK( xKey )
bKeyBlock := xKey
ELSE
bKeyBlock := {|| .T. }
ENDIF
aGetField := {}
AEval( aFields, {| cField | AAdd( aGetField, __GetField( cField ) ) } )
aFieldsSum := Array( Len( aGetField ) )
/* ; Keep it open after creating it. */
dbCreate( cFile, aNewDbStruct, cRDD, .T., "", NIL, cCodePage, nConnection )
nNewArea := Select()
dbSelectArea( nOldArea )
DO WHILE !Eof() .AND. nNext != 0 .AND. Eval( bWhileBlock )
lDbTransRecord := .F.
AFill( aFieldsSum, 0 )
xCurKey := Eval( bKeyBlock )
DO WHILE !Eof() .AND. nNext-- != 0 .AND. Eval( bWhileBlock ) .AND. ;
xCurKey == Eval( bKeyBlock )
IF Eval( bForBlock )
IF !lDbTransRecord
__dbTransRec( nNewArea, aNewDbStruct )
dbSelectArea( nOldArea )
lDbTransRecord := .T.
ENDIF
AEval( aGetField, {| bFieldBlock, nFieldPos | aFieldsSum[ nFieldPos ] += Eval( bFieldBlock ) } )
ENDIF
dbSkip()
ENDDO
IF lDbTransRecord
dbSelectArea( nNewArea )
AEval( aGetField, {| bFieldBlock, nFieldPos | Eval( bFieldBlock, aFieldsSum[ nFieldPos ] ) } )
dbSelectArea( nOldArea )
ENDIF
ENDDO
RECOVER USING oError
lError := .T.
END SEQUENCE
IF nNewArea != NIL
dbSelectArea( nNewArea )
dbCloseArea()
ENDIF
dbSelectArea( nOldArea )
IF lError
Break( oError )
ENDIF
RETURN .T.
| dbtotal.prg | 64 |
| STATIC FUNCTION | __GetField( cField )
STATIC FUNCTION __GetField( cField )
LOCAL nCurrArea := Select()
LOCAL nPos
LOCAL oError
LOCAL lError
/* ; Is the field aliased? */
IF ( nPos := At( "->", cField ) ) > 0
IF Select( Left( cField, nPos - 1 ) ) != nCurrArea
oError := ErrorNew()
oError:severity := ES_ERROR
oError:genCode := EG_SYNTAX
oError:subSystem := "DBCMD"
oError:canDefault := .T.
oError:operation := cField
oError:subCode := 1101
lError := Eval( ErrorBlock(), oError )
IF !ISLOGICAL( lError ) .OR. lError
__ErrInHandler()
ENDIF
Break( oError )
ENDIF
cField := SubStr( cField, nPos + 2 )
ENDIF
RETURN FieldBlock( cField )
| dbtotal.prg | 197 |
| FUNCTION | __dbTransRec( nDstArea, aFieldsStru )
FUNCTION __dbTransRec( nDstArea, aFieldsStru )
RETURN __dbTrans( nDstArea, aFieldsStru, NIL, NIL, 1 )
| dbtotal.prg | 230 |
| dbtotalx.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | dbTotal( cFile, xKey, aFields, xFor, xWhile, nNext, nRec, lRest )
FUNCTION dbTotal( cFile, xKey, aFields, xFor, xWhile, nNext, nRec, lRest )
RETURN __dbTotal( cFile, xKey, aFields, xFor, xWhile, nNext, nRec, lRest )
| dbtotalx.prg | 55 |
| dbupdat.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | __dbUpdate( cAlias, bKey, lRandom, bAssign )
FUNCTION __dbUpdate( cAlias, bKey, lRandom, bAssign )
LOCAL nOldArea := Select()
LOCAL xKey
LOCAL oError
LOCAL lError := .F.
DEFAULT lRandom TO .F.
dbGoTop()
BEGIN SEQUENCE
dbSelectArea( cAlias )
dbGoTop()
DO WHILE !Eof()
xKey := Eval( bKey )
dbSelectArea( nOldArea )
IF lRandom
IF dbSeek( xKey )
Eval( bAssign )
ENDIF
ELSE
DO WHILE Eval( bKey ) < xKey .AND. !Eof()
dbSkip()
ENDDO
IF Eval( bKey ) == xKey .AND. !Eof()
Eval( bAssign )
ENDIF
ENDIF
dbSelectArea( cAlias )
dbSkip()
ENDDO
RECOVER USING oError
lError := .T.
END SEQUENCE
dbSelectArea( nOldArea )
IF lError
Break( oError )
ENDIF
RETURN .T.
| dbupdat.prg | 55 |
| dbupdatx.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | dbUpdate( cAlias, bAssign, bKey, lRandom )
FUNCTION dbUpdate( cAlias, bAssign, bKey, lRandom )
RETURN __dbUpdate( cAlias, bKey, lRandom, bAssign )
| dbupdatx.prg | 55 |
| rddord.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | dbCreateIndex( cOrderBagName, cKeyExpr, bKeyExpr, lUnique, cOrderName )
FUNCTION dbCreateIndex( cOrderBagName, cKeyExpr, bKeyExpr, lUnique, cOrderName )
RETURN ordCreate( cOrderBagName, cOrderName, cKeyExpr, bKeyExpr, lUnique )
| rddord.prg | 58 |
| FUNCTION | dbSetIndex( cIndexName )
FUNCTION dbSetIndex( cIndexName )
RETURN ordListAdd( cIndexName )
| rddord.prg | 61 |
| FUNCTION | dbClearIndex()
FUNCTION dbClearIndex()
RETURN ordListClear()
| rddord.prg | 64 |
| FUNCTION | dbReindex()
FUNCTION dbReindex()
RETURN ordListRebuild()
| rddord.prg | 67 |
| PROCEDURE | dbSetOrder( nOrderNum )
PROCEDURE dbSetOrder( nOrderNum )
IF ISCHARACTER( nOrderNum ) .AND. !Empty( Val( nOrderNum ) )
nOrderNum := Val( nOrderNum )
ENDIF
ordSetFocus( nOrderNum )
RETURN
| rddord.prg | 70 |
| FUNCTION | IndexExt()
FUNCTION IndexExt()
RETURN ordBagExt()
| rddord.prg | 80 |
| FUNCTION | IndexKey( nOrder )
FUNCTION IndexKey( nOrder )
IF !ISNUMBER( nOrder )
RETURN ordKey( nOrder )
ENDIF
IF Used()
RETURN ordKey( nOrder )
ENDIF
RETURN ""
| rddord.prg | 83 |
| FUNCTION | ordSetRelation( xArea, bRelation, cRelation )
FUNCTION ordSetRelation( xArea, bRelation, cRelation )
RETURN dbSetRelation( xArea, bRelation, cRelation, .T. )
| rddord.prg | 95 |
| rddordu.prg |
| Type | Function | Source | Line |
|---|
| FUNCTION | _dtxCondSet( cFor, bFor, lAll, bWhile, bEval, nEvery, xDummy, nRecNo, nNext, nRecord, lRest )
FUNCTION _dtxCondSet( cFor, bFor, lAll, bWhile, bEval, nEvery, xDummy, nRecNo, nNext, nRecord, lRest )
HB_SYMBOL_UNUSED( xDummy )
RETURN ordCondSet( cFor, bFor, lAll, bWhile, bEval, nEvery, nRecNo, nNext, nRecord, lRest )
| rddordu.prg | 59 |
