static HB_ERRCODE sqlbaseSkipRaw( SQLBASEAREAP pArea, HB_LONG lToSkip )
{
HB_ERRCODE errCode;
if( pArea->lpdbPendingRel )
{
if( SELF_FORCEREL( ( AREAP ) pArea ) != HB_SUCCESS )
return HB_FAILURE;
}
if( lToSkip == 0 )
{
/* TODO: maybe gocold is enough here?! */
HB_BOOL bBof, bEof;
/* Save flags */
bBof = pArea->area.fBof;
bEof = pArea->area.fEof;
errCode = SELF_GOTO( ( AREAP ) pArea, pArea->ulRecNo );
/* Restore flags */
pArea->area.fBof = bBof;
pArea->area.fEof = bEof;
}
else if( lToSkip < 0 && ( HB_ULONG ) ( -lToSkip ) >= pArea->ulRecNo )
{
errCode = SELF_GOTO( ( AREAP ) pArea, 1 );
pArea->area.fBof = HB_TRUE;
}
else
errCode = SELF_GOTO( ( AREAP ) pArea, pArea->ulRecNo + lToSkip );
return errCode;
}
static HB_ERRCODE sqlbaseGoTop( SQLBASEAREAP pArea )
{
pArea->area.fTop = HB_TRUE;
pArea->area.fBottom = HB_FALSE;
if( SELF_GOTO( ( AREAP ) pArea, 1 ) == HB_FAILURE )
return HB_FAILURE;
return SELF_SKIPFILTER( ( AREAP ) pArea, 1 );
}
static HB_ERRCODE adsxSeek( ADSXAREAP pArea, HB_BOOL bSoftSeek, PHB_ITEM pKey, HB_BOOL bFindLast )
{
PMIXKEY pMixKey;
HB_ULONG ulKeyPos, ulRecNo;
HB_ERRCODE errCode;
HB_BOOL fFound = HB_FALSE;
if( ! pArea->pTagCurrent )
return SUPER_SEEK( ( AREAP ) pArea, bSoftSeek, pKey, bFindLast );
/* TODO: pKey type validation, EG_DATATYPE runtime error */
pMixKey = mixKeyNew( pKey, bFindLast ? ( HB_ULONG ) ( -1 ) : 0, pArea->pTagCurrent->bType,
pArea->pTagCurrent->uiLen );
/* reset any pending relations - I hope ACE make the same and the problem
reported in GOTO() does not exist here */
SELF_RESETREL( &pArea->adsarea );
mixFindKey( pArea->pTagCurrent, pMixKey, &ulKeyPos );
ulRecNo = 0;
if( bFindLast )
{
if( ulKeyPos > 0 && mixCompareKey( pArea->pTagCurrent, ulKeyPos - 1, pMixKey ) == -1 )
{
ulRecNo = pArea->pTagCurrent->pKeys[ ulKeyPos - 1 ]->rec;
fFound = HB_TRUE;
}
else if( ulKeyPos < pArea->pTagCurrent->ulRecCount )
{
ulRecNo = pArea->pTagCurrent->pKeys[ ulKeyPos ]->rec;
fFound = HB_FALSE;
}
}
else
{
if( ulKeyPos < pArea->pTagCurrent->ulRecCount )
{
ulRecNo = pArea->pTagCurrent->pKeys[ ulKeyPos ]->rec;
fFound = mixCompareKey( pArea->pTagCurrent, ulKeyPos, pMixKey ) == 1;
}
}
mixKeyFree( pMixKey );
ulRecNo = ( bSoftSeek || fFound ) ? ulRecNo : 0;
errCode = SELF_GOTO( ( AREAP ) pArea, ulRecNo );
pArea->adsarea.area.fEof = ulRecNo == 0;
pArea->adsarea.area.fBof = HB_FALSE;
pArea->adsarea.area.fFound = fFound;
pArea->adsarea.fPositioned = ! pArea->adsarea.area.fEof;
return errCode;
}
/*
* Position the cursor to a specific, physical identity.
*/
static HB_ERRCODE hb_sdfGoToId( SDFAREAP pArea, PHB_ITEM pItem )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_sdfGoToId(%p, %p)", pArea, pItem ) );
#ifndef HB_CLP_STRICT
if( HB_IS_NUMERIC( pItem ) )
return SELF_GOTO( &pArea->area, hb_itemGetNL( pItem ) );
#endif
/* generate RTE */
return SUPER_GOTOID( &pArea->area, pItem );
}
static HB_ERRCODE sqlbaseGoToId( SQLBASEAREAP pArea, PHB_ITEM pItem )
{
PHB_ITEM pError;
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 HB_FAILURE;
}
}
static HB_ERRCODE sqlbaseGoBottom( SQLBASEAREAP pArea )
{
if( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
return HB_FAILURE;
if( ! pArea->fFetched && pArea->pSDD->GoTo( pArea, ( HB_ULONG ) -1 ) == HB_FAILURE )
return HB_FAILURE;
pArea->area.fTop = HB_FALSE;
pArea->area.fBottom = HB_TRUE;
if( SELF_GOTO( ( AREAP ) pArea, pArea->ulRecCount ) != HB_SUCCESS )
return HB_FAILURE;
return SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
}
static HB_ERRCODE sqlbaseAppend( SQLBASEAREAP pArea, HB_BOOL bUnLockAll )
{
HB_SYMBOL_UNUSED( bUnLockAll );
/* This GOTO is GOCOLD + GOEOF */
if( SELF_GOTO( ( AREAP ) pArea, 0 ) == HB_FAILURE )
return HB_FAILURE;
if( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == HB_FAILURE )
return HB_FAILURE;
if( pArea->ulRecCount + 1 >= pArea->ulRecMax )
{
pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) );
pArea->ulRecMax += SQLDD_ROWSET_RESIZE;
}
pArea->fAppend = pArea->fPositioned = HB_TRUE;
pArea->ulRecCount++;
pArea->ulRecNo = pArea->ulRecCount;
pArea->area.fBof = pArea->area.fEof = pArea->area.fFound = HB_FALSE;
return HB_SUCCESS;
}
static HB_ERRCODE adsxSkip( ADSXAREAP pArea, HB_LONG lToSkip )
{
PMIXKEY pKey;
HB_ULONG ulKeyPos;
HB_ERRCODE errCode = HB_SUCCESS;
if( ! pArea->pTagCurrent || lToSkip == 0 )
return SUPER_SKIP( ( AREAP ) pArea, lToSkip );
/* resolve any pending relations */
if( pArea->adsarea.lpdbPendingRel )
SELF_FORCEREL( ( AREAP ) pArea );
pArea->adsarea.area.fTop = pArea->adsarea.area.fBottom = HB_FALSE;
if( lToSkip > 0 )
{
if( ! pArea->adsarea.fPositioned )
{
errCode = SELF_GOTO( ( AREAP ) pArea, pArea->adsarea.ulRecNo );
}
else
{
pArea->adsarea.area.fEof = HB_FALSE;
}
pKey = mixKeyEval( pArea->pTagCurrent, pArea );
if( mixFindKey( pArea->pTagCurrent, pKey, &ulKeyPos ) &&
pArea->pTagCurrent->ulRecCount > ( HB_ULONG ) lToSkip &&
ulKeyPos < pArea->pTagCurrent->ulRecCount - ( HB_ULONG ) lToSkip )
{
if( SELF_GOTO( ( AREAP ) pArea, pArea->pTagCurrent->pKeys[ ulKeyPos + lToSkip ]->rec ) == HB_FAILURE )
errCode = HB_FAILURE;
pArea->adsarea.fPositioned = HB_TRUE;
pArea->adsarea.area.fEof = HB_FALSE;
}
else
{
SELF_GOTO( ( AREAP ) pArea, 0 );
pArea->adsarea.fPositioned = HB_FALSE;
pArea->adsarea.area.fEof = HB_TRUE;
}
mixKeyFree( pKey );
pArea->adsarea.area.fBof = HB_FALSE;
}
else
{
if( ! pArea->adsarea.fPositioned )
{
errCode = SELF_GOBOTTOM( ( AREAP ) pArea );
pArea->adsarea.area.fBottom = HB_FALSE;
++lToSkip;
}
else
{
pArea->adsarea.area.fBof = HB_FALSE;
}
pKey = mixKeyEval( pArea->pTagCurrent, pArea );
if( mixFindKey( pArea->pTagCurrent, pKey, &ulKeyPos ) &&
pArea->pTagCurrent->ulRecCount >= ( HB_ULONG ) ( -lToSkip ) &&
ulKeyPos >= ( HB_ULONG ) ( -lToSkip ) )
{
if( SELF_GOTO( ( AREAP ) pArea, pArea->pTagCurrent->pKeys[ ulKeyPos + lToSkip ]->rec ) == HB_FAILURE )
errCode = HB_FAILURE;
pArea->adsarea.area.fBof = HB_FALSE;
}
else
{
SELF_GOTOP( ( AREAP ) pArea );
pArea->adsarea.area.fBof = HB_TRUE;
}
mixKeyFree( pKey );
pArea->adsarea.area.fEof = HB_FALSE;
}
/* Force relational movement in child WorkAreas */
if( pArea->adsarea.area.lpdbRelations )
SELF_SYNCCHILDREN( ( AREAP ) pArea );
return errCode;
}
static PMIXTAG mixTagCreate( const char * szTagName, PHB_ITEM pKeyExpr, PHB_ITEM pKeyItem,
PHB_ITEM pForItem, PHB_ITEM pWhileItem, HB_BYTE bType,
HB_USHORT uiLen, ADSXAREAP pArea )
{
PMIXTAG pTag;
PMIXKEY pKey;
LPDBORDERCONDINFO pOrdCondInfo = pArea->adsarea.area.lpdbOrdCondInfo;
ADSHANDLE hOrder;
HB_ULONG ulRec, ulStartRec, ulNextCount = 0;
HB_LONG lStep = 0;
PHB_ITEM pItem, pEvalItem = NULL;
pTag = ( PMIXTAG ) hb_xgrab( sizeof( MIXTAG ) );
memset( pTag, 0, sizeof( MIXTAG ) );
pTag->szName = ( char * ) hb_xgrab( MIX_MAXTAGNAMELEN + 1 );
hb_strncpyUpperTrim( pTag->szName, szTagName, MIX_MAXTAGNAMELEN );
pTag->szKeyExpr = ( char * ) hb_xgrab( hb_itemGetCLen( pKeyExpr ) + 1 );
hb_strncpyTrim( pTag->szKeyExpr, hb_itemGetCPtr( pKeyExpr ), hb_itemGetCLen( pKeyExpr ) );
/* TODO: for expresion */
pTag->szForExpr = NULL;
pTag->pKeyItem = pKeyItem;
pTag->pForItem = pForItem;
pTag->bType = bType;
pTag->uiLen = uiLen;
/* Use national support */
if( bType == 'C' && pArea->adsarea.area.cdPage &&
! HB_CDP_ISBINSORT( pArea->adsarea.area.cdPage ) )
pTag->pCodepage = pArea->adsarea.area.cdPage;
pTag->pKeys = ( PMIXKEY * ) hb_xgrab( sizeof( PMIXKEY ) * MIX_KEYPOOLFIRST );
pTag->ulRecMax = MIX_KEYPOOLFIRST;
ulStartRec = 0;
if( pOrdCondInfo )
{
pEvalItem = pOrdCondInfo->itmCobEval;
lStep = pOrdCondInfo->lStep;
}
if( ! pOrdCondInfo || pOrdCondInfo->fAll )
{
pArea->adsarea.hOrdCurrent = 0;
}
else
{
if( pOrdCondInfo->itmRecID )
ulStartRec = hb_itemGetNL( pOrdCondInfo->itmRecID );
if( ulStartRec )
{
ulNextCount = 1;
}
else if( pOrdCondInfo->fRest || pOrdCondInfo->lNextCount > 0 )
{
if( pOrdCondInfo->itmStartRecID )
ulStartRec = hb_itemGetNL( pOrdCondInfo->itmStartRecID );
if( ! ulStartRec )
ulStartRec = pArea->adsarea.ulRecNo;
if( pArea->adsarea.area.lpdbOrdCondInfo->lNextCount > 0 )
ulNextCount = pOrdCondInfo->lNextCount;
}
else if( ! pOrdCondInfo->fUseCurrent )
{
pArea->adsarea.hOrdCurrent = 0;
}
}
hOrder = pArea->adsarea.hOrdCurrent ? pArea->adsarea.hOrdCurrent :
pArea->adsarea.hTable;
if( ulStartRec )
AdsGotoRecord( pArea->adsarea.hTable, ulStartRec );
else
AdsGotoTop( pArea->adsarea.hTable );
hb_adsUpdateAreaFlags( pArea );
while( ! pArea->adsarea.area.fEof )
{
SELF_RECNO( ( AREAP ) pArea, &ulRec );
SELF_GOTO( ( AREAP ) pArea, ulRec );
if( pEvalItem )
{
if( lStep >= pOrdCondInfo->lStep )
{
lStep = 0;
if( ! mixEvalCond( pEvalItem, NULL ) )
break;
}
++lStep;
}
if( pWhileItem && ! mixEvalCond( pWhileItem, NULL ) )
{
break;
}
if( pForItem == NULL || mixEvalCond( pForItem, NULL ) )
{
pItem = hb_vmEvalBlockOrMacro( pKeyItem );
pKey = mixKeyNew( pItem, ulRec, bType, uiLen );
if( pTag->ulRecCount == pTag->ulRecMax )
{
pTag->pKeys = ( PMIXKEY * ) hb_xrealloc( pTag->pKeys, sizeof( PMIXKEY ) * ( pTag->ulRecMax + MIX_KEYPOOLRESIZE ) );
pTag->ulRecMax += MIX_KEYPOOLRESIZE;
}
pTag->pKeys[ pTag->ulRecCount ] = pKey;
pTag->ulRecCount++;
}
if( ulNextCount )
{
ulNextCount--;
if( ! ulNextCount )
break;
}
AdsSkip( hOrder, 1 );
hb_adsUpdateAreaFlags( pArea );
}
/* QuickSort */
if( pTag->ulRecCount >= 2 )
mixQSort( pTag->pKeys, 0, pTag->ulRecCount - 1, uiLen, pTag->pCodepage );
return pTag;
}
static HB_ERRCODE adsxOrderInfo( ADSXAREAP pArea, HB_USHORT uiIndex, LPDBORDERINFO pOrderInfo )
{
PMIXTAG pTag = pArea->pTagCurrent;
/* resolve any pending relations */
if( pArea->adsarea.lpdbPendingRel )
SELF_FORCEREL( ( AREAP ) pArea );
/* all others need an index handle */
if( uiIndex != DBOI_ORDERCOUNT )
{
if( pOrderInfo->itmOrder )
{
if( HB_IS_STRING( pOrderInfo->itmOrder ) )
{
pTag = pArea->pTagList;
while( pTag )
{
if( ! hb_stricmp( hb_itemGetCPtr( pOrderInfo->itmOrder ), pTag->szName ) )
break;
pTag = pTag->pNext;
}
}
else if( HB_IS_NUMERIC( pOrderInfo->itmOrder ) )
{
UNSIGNED16 usOrder = 0, usSearch = ( UNSIGNED16 ) hb_itemGetNI( pOrderInfo->itmOrder );
AdsGetNumIndexes( pArea->adsarea.hTable, &usOrder );
pTag = usSearch <= usOrder ? NULL : pArea->pTagList;
while( pTag )
{
if( ++usOrder == usSearch )
break;
pTag = pTag->pNext;
}
}
}
if( ! pTag )
return SUPER_ORDINFO( ( AREAP ) pArea, uiIndex, pOrderInfo );
}
switch( uiIndex )
{
case DBOI_CONDITION:
hb_itemPutC( pOrderInfo->itmResult, pTag->szForExpr );
break;
case DBOI_EXPRESSION:
hb_itemPutC( pOrderInfo->itmResult, pTag->szKeyExpr );
break;
case DBOI_ISCOND:
hb_itemPutL( pOrderInfo->itmResult, pTag->pForItem != NULL );
break;
case DBOI_ISDESC:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
case DBOI_UNIQUE:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
case DBOI_KEYTYPE:
hb_itemPutCL( pOrderInfo->itmResult, ( char * ) &pTag->bType, 1 );
break;
case DBOI_KEYSIZE:
hb_itemPutNI( pOrderInfo->itmResult, pTag->uiLen );
break;
case DBOI_KEYVAL:
{
PHB_ITEM pItem;
PHB_CODEPAGE pCodepage = hb_cdpSelect( pArea->adsarea.area.cdPage );
pItem = hb_vmEvalBlockOrMacro( pTag->pKeyItem );
hb_cdpSelect( pCodepage );
hb_itemMove( pOrderInfo->itmResult, pItem );
break;
}
case DBOI_KEYCOUNT:
case DBOI_KEYCOUNTRAW: /* ignore filter but RESPECT SCOPE */
hb_itemPutNL( pOrderInfo->itmResult, pTag->ulRecCount );
break;
case DBOI_POSITION:
case DBOI_RECNO:
case DBOI_KEYNORAW:
if( uiIndex == DBOI_POSITION && pOrderInfo->itmNewVal && HB_IS_NUMERIC( pOrderInfo->itmNewVal ) )
{
HB_ULONG ulPos;
ulPos = hb_itemGetNL( pOrderInfo->itmNewVal );
if( ulPos > 0 && ulPos <= pTag->ulRecCount )
SELF_GOTO( ( AREAP ) pArea, pTag->pKeys[ ulPos - 1 ]->rec );
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, ! pArea->adsarea.area.fEof );
}
else
{
PMIXKEY pKey;
HB_ULONG ulKeyPos;
if( ! pArea->adsarea.fPositioned )
SELF_GOTO( ( AREAP ) pArea, pArea->adsarea.ulRecNo );
else
pArea->adsarea.area.fEof = HB_FALSE;
pKey = mixKeyEval( pTag, pArea );
hb_itemPutNL( pOrderInfo->itmResult,
mixFindKey( pTag, pKey, &ulKeyPos ) ? ( ulKeyPos + 1 ) : 0 );
mixKeyFree( pKey );
}
break;
case DBOI_RELKEYPOS:
if( pOrderInfo->itmNewVal && HB_IS_NUMERIC( pOrderInfo->itmNewVal ) )
{
HB_ULONG ulPos;
ulPos = ( HB_ULONG ) ( hb_itemGetND( pOrderInfo->itmNewVal ) * ( double ) pTag->ulRecCount );
if( ulPos > 0 && ulPos <= pTag->ulRecCount )
SELF_GOTO( ( AREAP ) pArea, pTag->pKeys[ ulPos - 1 ]->rec );
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, ! pArea->adsarea.area.fEof );
}
else
{
PMIXKEY pKey;
HB_ULONG ulKeyPos;
if( ! pArea->adsarea.fPositioned )
SELF_GOTO( ( AREAP ) pArea, pArea->adsarea.ulRecNo );
else
pArea->adsarea.area.fEof = HB_FALSE;
pKey = mixKeyEval( pTag, pArea );
if( ! mixFindKey( pTag, pKey, &ulKeyPos + 1 ) )
ulKeyPos = 0;
mixKeyFree( pKey );
pOrderInfo->itmResult = hb_itemPutND( pOrderInfo->itmResult,
( double ) ulKeyPos / ( double ) pTag->ulRecCount );
}
break;
case DBOI_NAME:
hb_itemPutC( pOrderInfo->itmResult, pTag->szName );
break;
case DBOI_BAGNAME:
hb_itemPutC( pOrderInfo->itmResult, NULL );
break;
case DBOI_FULLPATH:
hb_itemPutC( pOrderInfo->itmResult, NULL );
break;
case DBOI_BAGEXT:
hb_itemPutC( pOrderInfo->itmResult, "mix" );
break;
case DBOI_ORDERCOUNT:
{
UNSIGNED16 usOrder = 0;
AdsGetNumIndexes( pArea->adsarea.hTable, &usOrder );
pTag = pArea->pTagList;
while( pTag )
{
pTag = pTag->pNext;
usOrder++;
}
hb_itemPutNI( pOrderInfo->itmResult, ( int ) usOrder );
break;
}
case DBOI_NUMBER:
{
PMIXTAG pTag2;
UNSIGNED16 usOrder = 0;
AdsGetNumIndexes( pArea->adsarea.hTable, &usOrder );
pTag2 = pArea->pTagList;
usOrder++;
while( pTag2 && pTag != pTag2 )
{
pTag2 = pTag2->pNext;
usOrder++;
}
hb_itemPutNI( pOrderInfo->itmResult, ( int ) usOrder );
break;
}
case DBOI_CUSTOM:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
case DBOI_OPTLEVEL:
hb_itemPutNI( pOrderInfo->itmResult, DBOI_OPTIMIZED_NONE );
break;
case DBOI_KEYADD:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
case DBOI_KEYDELETE:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
case DBOI_AUTOOPEN:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
default:
return SUPER_ORDINFO( ( AREAP ) pArea, uiIndex, pOrderInfo );
}
return HB_SUCCESS;
}
static HB_ERRCODE adsxOrderCreate( ADSXAREAP pArea, LPDBORDERCREATEINFO pOrderInfo )
{
PMIXTAG pTagNew, pTag;
PHB_ITEM pKeyItem, pForItem = NULL, pWhileItem = NULL, pResult;
HB_ULONG ulRecNo;
HB_USHORT uiLen;
HB_BYTE bType;
UNSIGNED16 bValidExpr;
HB_BOOL bUseADS;
/* Test key expression */
bValidExpr = 0;
AdsIsExprValid( pArea->adsarea.hTable, ( UNSIGNED8 * ) hb_itemGetCPtr( pOrderInfo->abExpr ), &bValidExpr );
bUseADS = bValidExpr;
if( bUseADS && pArea->adsarea.area.lpdbOrdCondInfo )
{
/* Test FOR expression */
if( pArea->adsarea.area.lpdbOrdCondInfo->abFor )
{
bValidExpr = 0;
AdsIsExprValid( pArea->adsarea.hTable, ( UNSIGNED8 * ) pArea->adsarea.area.lpdbOrdCondInfo->abFor, &bValidExpr );
bUseADS = bValidExpr;
}
else if( pArea->adsarea.area.lpdbOrdCondInfo->itmCobFor )
{
bUseADS = HB_FALSE;
}
/* Test WHILE expression */
if( bUseADS )
{
if( pArea->adsarea.area.lpdbOrdCondInfo->abWhile )
{
bValidExpr = 0;
AdsIsExprValid( pArea->adsarea.hTable, ( UNSIGNED8 * ) pArea->adsarea.area.lpdbOrdCondInfo->abWhile, &bValidExpr );
bUseADS = ( bValidExpr != 0 );
}
else if( pArea->adsarea.area.lpdbOrdCondInfo->itmCobWhile )
bUseADS = HB_FALSE;
}
}
if( bUseADS )
{
return SUPER_ORDCREATE( ( AREAP ) pArea, pOrderInfo );
}
/* Obtain key codeblock */
if( pOrderInfo->itmCobExpr )
{
pKeyItem = hb_itemNew( pOrderInfo->itmCobExpr );
}
else
{
if( SELF_COMPILE( ( AREAP ) pArea, hb_itemGetCPtr( pOrderInfo->abExpr ) ) == HB_FAILURE )
return HB_FAILURE;
pKeyItem = pArea->adsarea.area.valResult;
pArea->adsarea.area.valResult = NULL;
}
/* Test key codeblock on EOF */
ulRecNo = pArea->adsarea.ulRecNo;
SELF_GOTO( ( AREAP ) pArea, 0 );
if( SELF_EVALBLOCK( ( AREAP ) pArea, pKeyItem ) == HB_FAILURE )
{
hb_vmDestroyBlockOrMacro( pKeyItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
return HB_FAILURE;
}
pResult = pArea->adsarea.area.valResult;
pArea->adsarea.area.valResult = NULL;
switch( hb_itemType( pResult ) )
{
case HB_IT_STRING:
case HB_IT_STRING | HB_IT_MEMO:
bType = 'C';
uiLen = ( HB_USHORT ) hb_itemGetCLen( pResult );
if( uiLen > MIX_MAXKEYLEN )
uiLen = MIX_MAXKEYLEN;
break;
case HB_IT_INTEGER:
case HB_IT_LONG:
case HB_IT_DOUBLE:
bType = 'N';
uiLen = 8;
break;
case HB_IT_DATE:
bType = 'D';
uiLen = 8;
break;
case HB_IT_LOGICAL:
bType = 'L';
uiLen = 1;
break;
default:
bType = 'U';
uiLen = 0;
}
hb_itemRelease( pResult );
if( bType == 'U' || uiLen == 0 )
{
hb_vmDestroyBlockOrMacro( pKeyItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
hb_mixErrorRT( pArea, bType == 'U' ? EG_DATATYPE : EG_DATAWIDTH, 1026, NULL, 0, 0 );
return HB_FAILURE;
}
if( pArea->adsarea.area.lpdbOrdCondInfo )
{
/* Obtain FOR codeblock */
if( pArea->adsarea.area.lpdbOrdCondInfo->itmCobFor )
{
pForItem = hb_itemNew( pArea->adsarea.area.lpdbOrdCondInfo->itmCobFor );
}
else if( pArea->adsarea.area.lpdbOrdCondInfo->abFor )
{
if( SELF_COMPILE( ( AREAP ) pArea, pArea->adsarea.area.lpdbOrdCondInfo->abFor ) == HB_FAILURE )
{
hb_vmDestroyBlockOrMacro( pKeyItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
return HB_FAILURE;
}
pForItem = pArea->adsarea.area.valResult;
pArea->adsarea.area.valResult = NULL;
}
/* Obtain WHILE codeblock */
if( pArea->adsarea.area.lpdbOrdCondInfo->itmCobWhile )
{
pWhileItem = hb_itemNew( pArea->adsarea.area.lpdbOrdCondInfo->itmCobWhile );
}
else if( pArea->adsarea.area.lpdbOrdCondInfo->abWhile )
{
if( SELF_COMPILE( ( AREAP ) pArea, pArea->adsarea.area.lpdbOrdCondInfo->abWhile ) == HB_FAILURE )
{
hb_vmDestroyBlockOrMacro( pKeyItem );
if( pForItem )
hb_vmDestroyBlockOrMacro( pForItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
return HB_FAILURE;
}
pWhileItem = pArea->adsarea.area.valResult;
pArea->adsarea.area.valResult = NULL;
}
}
/* Test FOR codeblock on EOF */
if( pForItem )
{
if( SELF_EVALBLOCK( ( AREAP ) pArea, pForItem ) == HB_FAILURE )
{
hb_vmDestroyBlockOrMacro( pKeyItem );
hb_vmDestroyBlockOrMacro( pForItem );
if( pWhileItem )
hb_vmDestroyBlockOrMacro( pWhileItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
return HB_FAILURE;
}
if( hb_itemType( pArea->adsarea.area.valResult ) != HB_IT_LOGICAL )
{
hb_itemRelease( pArea->adsarea.area.valResult );
pArea->adsarea.area.valResult = 0;
hb_vmDestroyBlockOrMacro( pKeyItem );
hb_vmDestroyBlockOrMacro( pForItem );
if( pWhileItem )
hb_vmDestroyBlockOrMacro( pWhileItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
hb_mixErrorRT( pArea, EG_DATATYPE, EDBF_INVALIDFOR, NULL, 0, 0 );
return HB_FAILURE;
}
hb_itemRelease( pArea->adsarea.area.valResult );
pArea->adsarea.area.valResult = NULL;
}
/* TODO: WHILE condition is not tested, like in DBFCDX. Why? Compatibility with Clipper? */
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
pTagNew = mixTagCreate( pOrderInfo->atomBagName, pOrderInfo->abExpr, pKeyItem,
pForItem, pWhileItem, bType, uiLen, pArea );
if( pWhileItem )
hb_vmDestroyBlockOrMacro( pWhileItem );
/* Append the tag to the end of list */
if( pArea->pTagList )
{
pTag = pArea->pTagList;
while( pTag->pNext )
pTag = pTag->pNext;
pTag->pNext = pTagNew;
}
else
{
pArea->pTagList = pTagNew;
}
pArea->pTagCurrent = pTagNew;
pArea->adsarea.hOrdCurrent = 0;
return HB_SUCCESS;
}
