c:\harbour\source\vm
arrays.c |
Type | Function | Source | Line |
STATIC VOID | hb_arrayReleaseItems( PHB_BASEARRAY pBaseArray )
static void hb_arrayReleaseItems( PHB_BASEARRAY pBaseArray )
{
if( pBaseArray->ulLen )
{
HB_ITEM_PTR pItems = pBaseArray->pItems;
ULONG ulLen = pBaseArray->ulLen;
/*
* clear the pBaseArray->pItems to avoid infinite loop in cross
* referenced items when pBaseArray is not freed due to buggy
* object destructor [druzus]
*/
pBaseArray->pItems = NULL;
pBaseArray->ulLen = 0;
while( ulLen-- )
{
if( HB_IS_COMPLEX( pItems + ulLen ) )
hb_itemClear( pItems + ulLen );
}
hb_xfree( pItems );
}
}
| arrays.c | 80 |
VOID | hb_arrayPushBase( PHB_BASEARRAY pBaseArray )
void hb_arrayPushBase( PHB_BASEARRAY pBaseArray )
{
PHB_ITEM pItem = hb_stackAllocItem();
pItem->type = HB_IT_ARRAY;
pItem->item.asArray.value = pBaseArray;
hb_gcRefInc( pBaseArray );
}
| arrays.c | 104 |
STATIC HB_GARBAGE_FUNC( | hb_arrayReleaseGarbage )
static HB_GARBAGE_FUNC( hb_arrayReleaseGarbage )
{
PHB_BASEARRAY pBaseArray = ( PHB_BASEARRAY ) Cargo;
if( pBaseArray->uiClass )
{
/*
* do not execute destructor for supercasted objects [druzus]
*/
if( pBaseArray->uiPrevCls == 0 &&
hb_clsHasDestructor( pBaseArray->uiClass ) )
{
hb_arrayPushBase( pBaseArray );
hb_objDestructorCall( hb_stackItemFromTop( -1 ) );
/* Clear object properities before hb_stackPop(), [druzus] */
pBaseArray->uiClass = 0;
hb_stackPop();
/*
* release array items before hb_gcRefCheck() to avoid double
* pBaseArray freeing when it will have cross references to
* self after executing buggy destructor [druzus]
*/
hb_arrayReleaseItems( pBaseArray );
hb_gcRefCheck( pBaseArray );
return;
}
/*
* This is only some additional protection for buggy code
* which can store reference to this object in other class
* destructor when executed from GC and it will only cause
* RT error when user will try to send any message to this
* object [druzus]
*/
pBaseArray->uiClass = 0;
}
hb_arrayReleaseItems( pBaseArray );
}
| arrays.c | 113 |
HB_EXPORT BOOL | hb_arrayNew( PHB_ITEM pItem, ULONG ulLen )
HB_EXPORT BOOL hb_arrayNew( PHB_ITEM pItem, ULONG ulLen ) /* creates a new array */
{
PHB_BASEARRAY pBaseArray;
PHB_ITEM pItems;
ULONG ulPos;
HB_TRACE(HB_TR_DEBUG, ("hb_arrayNew(%p, %lu)", pItem, ulLen));
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
/*
* allocate memory for items before hb_gcAlloc() to be
* safe for automatic GC activation in hb_xgrab() without
* calling hb_gcLock()/hb_gcUnlock(). [druzus]
*/
if( ulLen > 0 )
{
pItems = ( PHB_ITEM ) hb_xgrab( sizeof( HB_ITEM ) * ulLen );
for( ulPos = 0; ulPos < ulLen; ++ulPos )
( pItems + ulPos )->type = HB_IT_NIL;
}
else
pItems = NULL;
pBaseArray = ( PHB_BASEARRAY ) hb_gcAlloc( sizeof( HB_BASEARRAY ), hb_arrayReleaseGarbage );
pBaseArray->pItems = pItems;
pBaseArray->ulLen = ulLen;
pBaseArray->uiClass = 0;
pBaseArray->uiPrevCls = 0;
pItem->type = HB_IT_ARRAY;
pItem->item.asArray.value = pBaseArray;
return TRUE;
}
| arrays.c | 156 |
HB_EXPORT BOOL | hb_arraySize( PHB_ITEM pArray, ULONG ulLen )
HB_EXPORT BOOL hb_arraySize( PHB_ITEM pArray, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySize(%p, %lu)", pArray, ulLen));
if( HB_IS_ARRAY( pArray ) )
{
PHB_BASEARRAY pBaseArray = pArray->item.asArray.value;
if( ulLen != pBaseArray->ulLen )
{
ULONG ulPos;
if( pBaseArray->ulLen == 0 )
{
pBaseArray->pItems = ( PHB_ITEM ) hb_xgrab( ulLen * sizeof( HB_ITEM ) );
for( ulPos = 0; ulPos < ulLen; ulPos++ )
( pBaseArray->pItems + ulPos )->type = HB_IT_NIL;
}
else
{
if( pBaseArray->ulLen < ulLen )
{
pBaseArray->pItems = ( PHB_ITEM ) hb_xrealloc( pBaseArray->pItems, sizeof( HB_ITEM ) * ulLen );
/* set value for new items */
for( ulPos = pBaseArray->ulLen; ulPos < ulLen; ulPos++ )
( pBaseArray->pItems + ulPos )->type = HB_IT_NIL;
}
else if( pBaseArray->ulLen > ulLen )
{
/* release old items */
for( ulPos = ulLen; ulPos < pBaseArray->ulLen; ulPos++ )
{
if( HB_IS_COMPLEX( pBaseArray->pItems + ulPos ) )
hb_itemClear( pBaseArray->pItems + ulPos );
}
if( ulLen == 0 )
{
hb_xfree( pBaseArray->pItems );
pBaseArray->pItems = NULL;
}
else
pBaseArray->pItems = ( PHB_ITEM ) hb_xrealloc( pBaseArray->pItems, sizeof( HB_ITEM ) * ulLen );
}
}
pBaseArray->ulLen = ulLen;
}
return TRUE;
}
else
return FALSE;
}
| arrays.c | 193 |
HB_EXPORT ULONG | hb_arrayLen( PHB_ITEM pArray )
HB_EXPORT ULONG hb_arrayLen( PHB_ITEM pArray )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayLen(%p)", pArray));
if( HB_IS_ARRAY( pArray ) )
return pArray->item.asArray.value->ulLen;
else
return 0;
}
| arrays.c | 250 |
HB_EXPORT BOOL | hb_arrayIsObject( PHB_ITEM pArray )
HB_EXPORT BOOL hb_arrayIsObject( PHB_ITEM pArray )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayIsObject(%p)", pArray));
if( HB_IS_ARRAY( pArray ) )
return pArray->item.asArray.value->uiClass != 0;
else
return FALSE;
}
| arrays.c | 260 |
HB_EXPORT VOID * | hb_arrayId( PHB_ITEM pArray )
HB_EXPORT void * hb_arrayId( PHB_ITEM pArray )
{
if( HB_IS_ARRAY( pArray ) )
return ( void * ) pArray->item.asArray.value;
else
return NULL;
}
| arrays.c | 270 |
HB_EXPORT BOOL | hb_arrayAdd( PHB_ITEM pArray, PHB_ITEM pValue )
HB_EXPORT BOOL hb_arrayAdd( PHB_ITEM pArray, PHB_ITEM pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayAdd(%p, %p)", pArray, pValue));
if( HB_IS_ARRAY( pArray ) )
{
PHB_BASEARRAY pBaseArray = ( PHB_BASEARRAY ) pArray->item.asArray.value;
if( pBaseArray->ulLen < ULONG_MAX )
{
hb_arraySize( pArray, pBaseArray->ulLen + 1 );
pBaseArray = ( PHB_BASEARRAY ) pArray->item.asArray.value;
hb_itemCopy( pBaseArray->pItems + ( pBaseArray->ulLen - 1 ), pValue );
return TRUE;
}
}
return FALSE;
}
| arrays.c | 279 |
HB_EXPORT BOOL | hb_arrayAddForward( PHB_ITEM pArray, PHB_ITEM pValue )
HB_EXPORT BOOL hb_arrayAddForward( PHB_ITEM pArray, PHB_ITEM pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayAddForward(%p, %p)", pArray, pValue));
if( HB_IS_ARRAY( pArray ) )
{
PHB_BASEARRAY pBaseArray = ( PHB_BASEARRAY ) pArray->item.asArray.value;
if( pBaseArray->ulLen < ULONG_MAX )
{
hb_arraySize( pArray, pBaseArray->ulLen + 1 );
pBaseArray = ( PHB_BASEARRAY ) pArray->item.asArray.value;
hb_itemForwardValue( pBaseArray->pItems + ( pBaseArray->ulLen - 1 ), pValue );
return TRUE;
}
}
return FALSE;
}
| arrays.c | 300 |
HB_EXPORT BOOL | hb_arrayDel( PHB_ITEM pArray, ULONG ulIndex )
HB_EXPORT BOOL hb_arrayDel( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayDel(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) )
{
ULONG ulLen = pArray->item.asArray.value->ulLen;
if( ulIndex > 0 && ulIndex <= ulLen )
{
PHB_BASEARRAY pBaseArray = pArray->item.asArray.value;
if( ulIndex == ulLen )
{
hb_itemSetNil( pBaseArray->pItems + ulIndex - 1 );
}
else
{
for( ; ulIndex < ulLen; ++ulIndex ) /* move items */
hb_itemMoveRef( pBaseArray->pItems + ulIndex - 1,
pBaseArray->pItems + ulIndex );
}
return TRUE;
}
}
return FALSE;
}
| arrays.c | 321 |
HB_EXPORT BOOL | hb_arrayIns( PHB_ITEM pArray, ULONG ulIndex )
HB_EXPORT BOOL hb_arrayIns( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayIns(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) )
{
ULONG ulLen = pArray->item.asArray.value->ulLen;
if( ulIndex > 0 && ulIndex <= ulLen )
{
PHB_BASEARRAY pBaseArray = pArray->item.asArray.value;
if( ulIndex == ulLen )
{
hb_itemSetNil( pBaseArray->pItems + ulIndex - 1 );
}
else
{
while( --ulLen >= ulIndex ) /* move items */
hb_itemMoveRef( pBaseArray->pItems + ulLen,
pBaseArray->pItems + ulLen - 1 );
}
return TRUE;
}
}
return FALSE;
}
| arrays.c | 351 |
HB_EXPORT BOOL | hb_arraySet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
HB_EXPORT BOOL hb_arraySet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySet(%p, %lu, %p)", pArray, ulIndex, pItem));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemCopy( pArray->item.asArray.value->pItems + ( ulIndex - 1 ), pItem );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 381 |
HB_EXPORT BOOL | hb_arraySetForward( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
HB_EXPORT BOOL hb_arraySetForward( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetForward(%p, %lu, %p)", pArray, ulIndex, pItem));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemMove( pArray->item.asArray.value->pItems + ( ulIndex - 1 ), pItem );
return TRUE;
}
else
{
hb_itemClear( pItem );
return FALSE;
}
}
| arrays.c | 394 |
HB_EXPORT BOOL | hb_arrayGet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
HB_EXPORT BOOL hb_arrayGet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGet(%p, %lu, %p)", pArray, ulIndex, pItem));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemCopy( pItem, pArray->item.asArray.value->pItems + ( ulIndex - 1 ) );
return TRUE;
}
else
{
hb_itemSetNil( pItem );
return FALSE;
}
}
| arrays.c | 410 |
HB_EXPORT BOOL | hb_arrayGetItemRef( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
HB_EXPORT BOOL hb_arrayGetItemRef( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetItemRef(%p, %lu, %p)", pArray, ulIndex, pItem));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
if( pArray != pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
hb_gcRefInc( pArray->item.asArray.value );
}
pItem->type = HB_IT_BYREF;
pItem->item.asRefer.BasePtr.array = pArray->item.asArray.value;
pItem->item.asRefer.value = ulIndex - 1;
pItem->item.asRefer.offset = 0;
return TRUE;
}
else
{
hb_itemSetNil( pItem );
return FALSE;
}
}
| arrays.c | 426 |
PHB_ITEM | hb_arrayGetItemPtr( PHB_ITEM pArray, ULONG ulIndex )
PHB_ITEM hb_arrayGetItemPtr( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetItemPtr(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return pArray->item.asArray.value->pItems + ulIndex - 1;
else
return NULL;
}
| arrays.c | 451 |
CHAR * | hb_arrayGetDS( PHB_ITEM pArray, ULONG ulIndex, char * szDate )
char * hb_arrayGetDS( PHB_ITEM pArray, ULONG ulIndex, char * szDate )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetDS(%p, %lu, %s)", pArray, ulIndex, szDate));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetDS( pArray->item.asArray.value->pItems + ulIndex - 1, szDate );
else
/* NOTE: Intentionally calling it with a bad parameter in order to get
the default value from hb_itemGetDS(). [vszakats] */
return hb_itemGetDS( NULL, szDate );
}
| arrays.c | 465 |
LONG | hb_arrayGetDL( PHB_ITEM pArray, ULONG ulIndex )
long hb_arrayGetDL( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetDL(%p, %lu)", pArray, ulIndex ));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetDL( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
/* NOTE: Intentionally calling it with a bad parameter in order to get
the default value from hb_itemGetDL(). [vszakats] */
return hb_itemGetDL( NULL );
}
| arrays.c | 477 |
BOOL | hb_arrayGetL( PHB_ITEM pArray, ULONG ulIndex )
BOOL hb_arrayGetL( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetL(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetL( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
return FALSE;
}
| arrays.c | 489 |
INT | hb_arrayGetNI( PHB_ITEM pArray, ULONG ulIndex )
int hb_arrayGetNI( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNI(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetNI( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
return 0;
}
| arrays.c | 499 |
LONG | hb_arrayGetNL( PHB_ITEM pArray, ULONG ulIndex )
long hb_arrayGetNL( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNL(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetNL( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
return 0;
}
| arrays.c | 509 |
LONGLONG | hb_arrayGetNLL( PHB_ITEM pArray, ULONG ulIndex )
LONGLONG hb_arrayGetNLL( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNLL(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetNLL( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
return 0;
}
| arrays.c | 520 |
HB_LONG | hb_arrayGetNInt( PHB_ITEM pArray, ULONG ulIndex )
HB_LONG hb_arrayGetNInt( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNLL(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetNInt( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
return 0;
}
| arrays.c | 531 |
DOUBLE | hb_arrayGetND( PHB_ITEM pArray, ULONG ulIndex )
double hb_arrayGetND( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetND(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetND( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
return 0;
}
| arrays.c | 541 |
ULONG | hb_arrayCopyC( PHB_ITEM pArray, ULONG ulIndex, char * szBuffer, ULONG ulLen )
ULONG hb_arrayCopyC( PHB_ITEM pArray, ULONG ulIndex, char * szBuffer, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopyC(%p, %lu, %s, %lu)", pArray, ulIndex, szBuffer, ulLen));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemCopyC( pArray->item.asArray.value->pItems + ulIndex - 1, szBuffer, ulLen );
else
return 0;
}
| arrays.c | 551 |
CHAR * | hb_arrayGetC( PHB_ITEM pArray, ULONG ulIndex )
char * hb_arrayGetC( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetC(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetC( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
return NULL;
}
| arrays.c | 561 |
CHAR * | hb_arrayGetCPtr( PHB_ITEM pArray, ULONG ulIndex )
char * hb_arrayGetCPtr( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetCPtr(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetCPtr( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
return "";
}
| arrays.c | 571 |
ULONG | hb_arrayGetCLen( PHB_ITEM pArray, ULONG ulIndex )
ULONG hb_arrayGetCLen( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetCLen(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetCLen( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
return 0;
}
| arrays.c | 581 |
VOID * | hb_arrayGetPtr( PHB_ITEM pArray, ULONG ulIndex )
void * hb_arrayGetPtr( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetPtr(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetPtr( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
return NULL;
}
| arrays.c | 591 |
HB_TYPE | hb_arrayGetType( PHB_ITEM pArray, ULONG ulIndex )
HB_TYPE hb_arrayGetType( PHB_ITEM pArray, ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetType(%p, %lu)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemType( pArray->item.asArray.value->pItems + ulIndex - 1 );
else
return 0;
}
| arrays.c | 602 |
HB_EXPORT BOOL | hb_arraySetDS( PHB_ITEM pArray, ULONG ulIndex, char * szDate )
HB_EXPORT BOOL hb_arraySetDS( PHB_ITEM pArray, ULONG ulIndex, char * szDate )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetDS(%p, %lu, %s)", pArray, ulIndex, szDate));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutDS( pArray->item.asArray.value->pItems + ulIndex - 1, szDate );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 612 |
HB_EXPORT BOOL | hb_arraySetDL( PHB_ITEM pArray, ULONG ulIndex, LONG lDate )
HB_EXPORT BOOL hb_arraySetDL( PHB_ITEM pArray, ULONG ulIndex, LONG lDate )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetDL(%p, %lu, %ld)", pArray, ulIndex, lDate));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutDL( pArray->item.asArray.value->pItems + ulIndex - 1, lDate );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 625 |
HB_EXPORT BOOL | hb_arraySetL( PHB_ITEM pArray, ULONG ulIndex, BOOL fValue )
HB_EXPORT BOOL hb_arraySetL( PHB_ITEM pArray, ULONG ulIndex, BOOL fValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetL(%p, %lu, %d)", pArray, ulIndex, fValue));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutL( pArray->item.asArray.value->pItems + ulIndex - 1, fValue );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 638 |
HB_EXPORT BOOL | hb_arraySetNI( PHB_ITEM pArray, ULONG ulIndex, int iNumber )
HB_EXPORT BOOL hb_arraySetNI( PHB_ITEM pArray, ULONG ulIndex, int iNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNI(%p, %lu, %d)", pArray, ulIndex, iNumber));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutNI( pArray->item.asArray.value->pItems + ulIndex - 1, iNumber );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 651 |
HB_EXPORT BOOL | hb_arraySetNL( PHB_ITEM pArray, ULONG ulIndex, LONG lNumber )
HB_EXPORT BOOL hb_arraySetNL( PHB_ITEM pArray, ULONG ulIndex, LONG lNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNL(%p, %lu, %lu)", pArray, ulIndex, lNumber));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutNL( pArray->item.asArray.value->pItems + ulIndex - 1, lNumber );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 664 |
HB_EXPORT BOOL | hb_arraySetNLL( PHB_ITEM pArray, ULONG ulIndex, LONGLONG llNumber )
HB_EXPORT BOOL hb_arraySetNLL( PHB_ITEM pArray, ULONG ulIndex, LONGLONG llNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNLL(%p, %lu, %" PFLL "d)", pArray, ulIndex, llNumber));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutNLL( pArray->item.asArray.value->pItems + ulIndex - 1, llNumber );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 678 |
HB_EXPORT BOOL | hb_arraySetNInt( PHB_ITEM pArray, ULONG ulIndex, HB_LONG lNumber )
HB_EXPORT BOOL hb_arraySetNInt( PHB_ITEM pArray, ULONG ulIndex, HB_LONG lNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNInt(%p, %lu, %" PFHL "d)", pArray, ulIndex, lNumber));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutNInt( pArray->item.asArray.value->pItems + ulIndex - 1, lNumber );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 692 |
HB_EXPORT BOOL | hb_arraySetND( PHB_ITEM pArray, ULONG ulIndex, double dNumber )
HB_EXPORT BOOL hb_arraySetND( PHB_ITEM pArray, ULONG ulIndex, double dNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetND(%p, %lu, %lf)", pArray, ulIndex, dNumber));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutND( pArray->item.asArray.value->pItems + ulIndex - 1, dNumber );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 705 |
HB_EXPORT BOOL | hb_arraySetC( PHB_ITEM pArray, ULONG ulIndex, const char * szText )
HB_EXPORT BOOL hb_arraySetC( PHB_ITEM pArray, ULONG ulIndex, const char * szText )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %lu, %p)", pArray, ulIndex, szText));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutC( pArray->item.asArray.value->pItems + ulIndex - 1, szText );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 718 |
HB_EXPORT BOOL | hb_arraySetCL( PHB_ITEM pArray, ULONG ulIndex, const char * szText, ULONG ulLen )
HB_EXPORT BOOL hb_arraySetCL( PHB_ITEM pArray, ULONG ulIndex, const char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %lu, %p, %lu)", pArray, ulIndex, szText, ulLen));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutCL( pArray->item.asArray.value->pItems + ulIndex - 1, szText, ulLen );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 731 |
HB_EXPORT BOOL | hb_arraySetCPtr( PHB_ITEM pArray, ULONG ulIndex, char * szText, ULONG ulLen )
HB_EXPORT BOOL hb_arraySetCPtr( PHB_ITEM pArray, ULONG ulIndex, char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetCPtr(%p, %lu)", pArray, ulIndex, szText, ulLen));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutCLPtr( pArray->item.asArray.value->pItems + ulIndex - 1, szText, ulLen );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 744 |
HB_EXPORT BOOL | hb_arraySetPtr( PHB_ITEM pArray, ULONG ulIndex, void * pValue )
HB_EXPORT BOOL hb_arraySetPtr( PHB_ITEM pArray, ULONG ulIndex, void * pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetPtr(%p, %lu, %p)", pArray, ulIndex, pValue));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutPtr( pArray->item.asArray.value->pItems + ulIndex - 1, pValue );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 757 |
HB_EXPORT BOOL | hb_arraySetPtrGC( PHB_ITEM pArray, ULONG ulIndex, void * pValue )
HB_EXPORT BOOL hb_arraySetPtrGC( PHB_ITEM pArray, ULONG ulIndex, void * pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetPtrGC(%p, %lu, %p)", pArray, ulIndex, pValue));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
hb_itemPutPtrGC( pArray->item.asArray.value->pItems + ulIndex - 1, pValue );
return TRUE;
}
else
return FALSE;
}
| arrays.c | 770 |
BOOL | hb_arrayLast( PHB_ITEM pArray, PHB_ITEM pResult )
BOOL hb_arrayLast( PHB_ITEM pArray, PHB_ITEM pResult )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayLast(%p, %p)", pArray, pResult));
if( HB_IS_ARRAY( pArray ) )
{
if( pArray->item.asArray.value->ulLen > 0 )
hb_itemCopy( pResult, pArray->item.asArray.value->pItems +
( pArray->item.asArray.value->ulLen - 1 ) );
else
hb_itemSetNil( pResult );
return TRUE;
}
hb_itemSetNil( pResult );
return FALSE;
}
| arrays.c | 783 |
BOOL | hb_arrayFill( PHB_ITEM pArray, PHB_ITEM pValue, ULONG * pulStart, ULONG * pulCount )
BOOL hb_arrayFill( PHB_ITEM pArray, PHB_ITEM pValue, ULONG * pulStart, ULONG * pulCount )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayFill(%p, %p, %p, %p)", pArray, pValue, pulStart, pulCount));
if( HB_IS_ARRAY( pArray ) )
{
PHB_BASEARRAY pBaseArray = pArray->item.asArray.value;
ULONG ulLen = pBaseArray->ulLen;
ULONG ulStart;
ULONG ulCount;
if( pulStart && *pulStart )
ulStart = *pulStart - 1;
else
ulStart = 0;
if( ulStart < ulLen )
{
ulCount = ulLen - ulStart;
if( pulCount && *pulCount < ulCount )
ulCount = *pulCount;
if( ulCount > 0 )
{
do
{
hb_itemCopy( pBaseArray->pItems + ulStart++, pValue );
}
while( --ulCount > 0 );
}
}
return TRUE;
}
else
return FALSE;
}
| arrays.c | 803 |
ULONG | hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, ULONG * pulStart, ULONG * pulCount, BOOL fExact )
ULONG hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, ULONG * pulStart, ULONG * pulCount, BOOL fExact )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayScan(%p, %p, %p, %p, %d)", pArray, pValue, pulStart, pulCount, (int) fExact));
if( HB_IS_ARRAY( pArray ) )
{
PHB_BASEARRAY pBaseArray = pArray->item.asArray.value;
ULONG ulLen = pBaseArray->ulLen;
ULONG ulStart;
ULONG ulCount;
if( pulStart && *pulStart )
ulStart = *pulStart - 1;
else
ulStart = 0;
if( ulStart < ulLen )
{
ulCount = ulLen - ulStart;
if( pulCount && *pulCount < ulCount )
ulCount = *pulCount;
if( ulCount > 0 )
{
/* Make separate search loops for different types to find, so that
the loop can be faster. */
if( HB_IS_BLOCK( pValue ) )
{
do
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pValue );
hb_vmPush( pBaseArray->pItems + ulStart );
hb_vmPushLong( ++ulStart );
hb_vmDo( 2 );
if( HB_IS_LOGICAL( hb_stackReturnItem() ) && hb_stackReturnItem()->item.asLogical.value )
return ulStart;
}
while( --ulCount > 0 && ulStart < pBaseArray->ulLen );
}
else if( HB_IS_STRING( pValue ) )
{
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart++;
/* NOTE: The order of the pItem and pValue parameters passed to
hb_itemStrCmp() is significant, please don't change it. [vszakats] */
if( HB_IS_STRING( pItem ) && hb_itemStrCmp( pItem, pValue, fExact ) == 0 )
return ulStart;
}
while( --ulCount > 0 );
}
else if( HB_IS_NUMERIC( pValue ) )
{
double dValue = hb_itemGetND( pValue );
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart++;
if( HB_IS_NUMERIC( pItem ) && hb_itemGetND( pItem ) == dValue )
return ulStart;
}
while( --ulCount > 0 );
}
else if( HB_IS_DATE( pValue ) )
{
long lValue = hb_itemGetDL( pValue ); /* NOTE: This is correct: Get the date as a long value. [vszakats] */
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart++;
if( HB_IS_DATE( pItem ) && hb_itemGetDL( pItem ) == lValue )
return ulStart;
}
while( --ulCount > 0 );
}
else if( HB_IS_LOGICAL( pValue ) )
{
BOOL bValue = hb_itemGetL( pValue );
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart++;
if( HB_IS_LOGICAL( pItem ) && hb_itemGetL( pItem ) == bValue )
return ulStart;
}
while( --ulCount > 0 );
}
else if( HB_IS_NIL( pValue ) )
{
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart++;
if( HB_IS_NIL( pItem ) )
return ulStart;
}
while( --ulCount > 0 );
}
else if( HB_IS_POINTER( pValue ) )
{
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart++;
if( HB_IS_POINTER( pItem ) &&
pItem->item.asPointer.value == pValue->item.asPointer.value )
return ulStart;
}
while( --ulCount > 0 );
}
else if( fExact && HB_IS_ARRAY( pValue ) )
{
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart++;
if( HB_IS_ARRAY( pItem ) &&
pItem->item.asArray.value == pValue->item.asArray.value )
return ulStart;
}
while( --ulCount > 0 );
}
else if( fExact && HB_IS_HASH( pValue ) )
{
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart++;
if( HB_IS_HASH( pItem ) &&
pItem->item.asHash.value == pValue->item.asHash.value )
return ulStart;
}
while( --ulCount > 0 );
}
}
}
}
return 0;
}
| arrays.c | 841 |
ULONG | hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, ULONG * pulStart, ULONG * pulCount, BOOL fExact )
ULONG hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, ULONG * pulStart, ULONG * pulCount, BOOL fExact )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayRevScan(%p, %p, %p, %p, %d)", pArray, pValue, pulStart, pulCount, (int) fExact));
if( HB_IS_ARRAY( pArray ) )
{
PHB_BASEARRAY pBaseArray = pArray->item.asArray.value;
ULONG ulLen = pBaseArray->ulLen;
ULONG ulStart;
ULONG ulCount;
if( pulStart && *pulStart )
ulStart = *pulStart - 1;
else
ulStart = ulLen - 1;
if( ulStart < ulLen )
{
ulCount = ulStart + 1;
if( pulCount && *pulCount < ulCount )
ulCount = *pulCount;
if( ulCount > 0 )
{
/* Make separate search loops for different types to find, so that
the loop can be faster. */
if( HB_IS_BLOCK( pValue ) )
{
do
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pValue );
hb_vmPush( pBaseArray->pItems + ulStart );
hb_vmPushLong( ulStart + 1 );
hb_vmDo( 2 );
if( HB_IS_LOGICAL( hb_stackReturnItem() ) && hb_stackReturnItem()->item.asLogical.value )
return ulStart + 1;
}
while( --ulCount && ulStart-- );
}
else if( HB_IS_STRING( pValue ) )
{
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart;
/* NOTE: The order of the pItem and pValue parameters passed to
hb_itemStrCmp() is significant, please don't change it. [vszakats] */
if( HB_IS_STRING( pItem ) && hb_itemStrCmp( pItem, pValue, fExact ) == 0 )
return ulStart + 1;
}
while( --ulCount && ulStart-- );
}
else if( HB_IS_NUMERIC( pValue ) )
{
double dValue = hb_itemGetND( pValue );
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart;
if( HB_IS_NUMERIC( pItem ) && hb_itemGetND( pItem ) == dValue )
return ulStart + 1;
}
while( --ulCount && ulStart-- );
}
else if( HB_IS_DATE( pValue ) )
{
long lValue = hb_itemGetDL( pValue ); /* NOTE: This is correct: Get the date as a long value. [vszakats] */
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart;
if( HB_IS_DATE( pItem ) && hb_itemGetDL( pItem ) == lValue )
return ulStart + 1;
}
while( --ulCount && ulStart-- );
}
else if( HB_IS_LOGICAL( pValue ) )
{
BOOL bValue = hb_itemGetL( pValue );
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart;
if( HB_IS_LOGICAL( pItem ) && hb_itemGetL( pItem ) == bValue )
return ulStart + 1;
}
while( --ulCount && ulStart-- );
}
else if( HB_IS_NIL( pValue ) )
{
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart;
if( HB_IS_NIL( pItem ) )
return ulStart + 1;
}
while( --ulCount && ulStart-- );
}
else if( HB_IS_POINTER( pValue ) )
{
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart;
if( HB_IS_POINTER( pItem ) &&
pItem->item.asPointer.value == pValue->item.asPointer.value )
return ulStart + 1;
}
while( --ulCount && ulStart-- );
}
else if( fExact && HB_IS_ARRAY( pValue ) )
{
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart;
if( HB_IS_ARRAY( pItem ) &&
pItem->item.asArray.value == pValue->item.asArray.value )
return ulStart + 1;
}
while( --ulCount && ulStart-- );
}
else if( fExact && HB_IS_HASH( pValue ) )
{
do
{
PHB_ITEM pItem = pBaseArray->pItems + ulStart;
if( HB_IS_HASH( pItem ) &&
pItem->item.asHash.value == pValue->item.asHash.value )
return ulStart + 1;
}
while( --ulCount && ulStart-- );
}
}
}
}
return 0;
}
| arrays.c | 989 |
BOOL | hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, ULONG * pulStart, ULONG * pulCount )
BOOL hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, ULONG * pulStart, ULONG * pulCount )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayEval(%p, %p, %p, %p)", pArray, bBlock, pulStart, pulCount));
if( HB_IS_ARRAY( pArray ) && HB_IS_BLOCK( bBlock ) )
{
PHB_BASEARRAY pBaseArray = pArray->item.asArray.value;
ULONG ulLen = pBaseArray->ulLen;
ULONG ulStart;
ULONG ulCount;
if( pulStart && *pulStart )
ulStart = *pulStart - 1;
else
ulStart = 0;
if( ulStart < ulLen )
{
ulCount = ulLen - ulStart;
if( pulCount && *pulCount < ulCount )
ulCount = *pulCount;
if( ulCount > 0 )
{
do
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( bBlock );
hb_vmPush( pBaseArray->pItems + ulStart );
hb_vmPushLong( ulStart + 1 );
hb_vmDo( 2 );
}
while( --ulCount > 0 && ++ulStart < pBaseArray->ulLen );
/*
* checking for ulStart < pBaseArray->ulLen is fix for
* possible GPF when codeblock decrease array size
*/
}
}
return TRUE;
}
else
return FALSE;
}
| arrays.c | 1137 |
BOOL | hb_arrayCopy( PHB_ITEM pSrcArray, PHB_ITEM pDstArray, ULONG * pulStart, ULONG * pulCount, ULONG * pulTarget )
BOOL hb_arrayCopy( PHB_ITEM pSrcArray, PHB_ITEM pDstArray, ULONG * pulStart,
ULONG * pulCount, ULONG * pulTarget )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopy(%p, %p, %p, %p, %p)", pSrcArray, pDstArray, pulStart, pulCount, pulTarget));
if( HB_IS_ARRAY( pSrcArray ) && HB_IS_ARRAY( pDstArray ) )
{
PHB_BASEARRAY pSrcBaseArray = pSrcArray->item.asArray.value;
PHB_BASEARRAY pDstBaseArray = pDstArray->item.asArray.value;
ULONG ulSrcLen = pSrcBaseArray->ulLen;
ULONG ulDstLen = pDstBaseArray->ulLen;
ULONG ulStart;
ULONG ulCount;
ULONG ulTarget;
if( pulStart && ( *pulStart >= 1 ) )
ulStart = *pulStart;
else
ulStart = 1;
if( pulTarget && ( *pulTarget >= 1 ) )
ulTarget = *pulTarget;
else
ulTarget = 1;
#ifdef HB_COMPAT_C53 /* From CA-Cl*pper 5.3a */
if( ulStart <= ulSrcLen )
#else
if( ulSrcLen > 0 )
#endif
{
#ifndef HB_COMPAT_C53 /* From CA-Cl*pper 5.3a */
if( ulStart > ulSrcLen )
ulStart = ulSrcLen;
#endif
if( pulCount && ( *pulCount <= ulSrcLen - ulStart ) )
ulCount = *pulCount;
else
ulCount = ulSrcLen - ulStart + 1;
/* This is probably a bug, present in all versions of CA-Cl*pper. */
#if defined( HB_C52_STRICT ) || 1
if( ulDstLen > 0 )
{
if( ulTarget > ulDstLen )
ulTarget = ulDstLen;
#else
if( ulTarget <= ulDstLen )
{
#endif
if( ulCount > ulDstLen - ulTarget )
ulCount = ulDstLen - ulTarget + 1;
for( ulTarget--, ulStart--; ulCount > 0; ulCount--, ulStart++, ulTarget++ )
hb_itemCopy( pDstBaseArray->pItems + ulTarget, pSrcBaseArray->pItems + ulStart );
}
}
return TRUE;
}
else
return FALSE;
}
static void hb_arrayCloneBody( PHB_BASEARRAY pSrcBaseArray, PHB_BASEARRAY pDstBaseArray, PHB_NESTED_CLONED pClonedList )
{
PHB_ITEM pSrcItem, pDstItem;
ULONG ulLen;
HB_TRACE(HB_TR_DEBUG, ("hb_arrayCloneBody(%p, %p, %p)", pSrcBaseArray, pDstBaseArray, pClonedList));
pSrcItem = pSrcBaseArray->pItems;
pDstItem = pDstBaseArray->pItems;
pDstBaseArray->uiClass = pSrcBaseArray->uiClass;
for( ulLen = pSrcBaseArray->ulLen; ulLen; --ulLen, ++pSrcItem, ++pDstItem )
hb_cloneNested( pDstItem, pSrcItem, pClonedList );
}
void hb_cloneNested( PHB_ITEM pDstItem, PHB_ITEM pSrcItem, PHB_NESTED_CLONED pClonedList )
{
/* Clipper clones nested array ONLY if NOT an Object!!! */
if( HB_IS_ARRAY( pSrcItem ) && pSrcItem->item.asArray.value->uiClass == 0 )
{
PHB_NESTED_CLONED pCloned = pClonedList;
PHB_BASEARRAY pBaseArray = pSrcItem->item.asArray.value;
do
{
if( pCloned->value == ( void * ) pBaseArray )
break;
pCloned = pCloned->pNext;
}
while( pCloned );
if( pCloned )
hb_itemCopy( pDstItem, pCloned->pDest );
else
{
hb_arrayNew( pDstItem, pBaseArray->ulLen );
pCloned = ( PHB_NESTED_CLONED ) hb_xgrab( sizeof( HB_NESTED_CLONED ) );
pCloned->value = ( void * ) pBaseArray;
pCloned->pDest = pDstItem;
pCloned->pNext = pClonedList->pNext;
pClonedList->pNext = pCloned;
hb_arrayCloneBody( pBaseArray, pDstItem->item.asArray.value, pClonedList );
}
}
else if( HB_IS_HASH( pSrcItem ) )
{
PHB_NESTED_CLONED pCloned = pClonedList;
PHB_BASEHASH pBaseHash = pSrcItem->item.asHash.value;
do
{
if( pCloned->value == ( void * ) pBaseHash )
break;
pCloned = pCloned->pNext;
}
while( pCloned );
if( pCloned )
hb_itemCopy( pDstItem, pCloned->pDest );
else
{
pCloned = ( PHB_NESTED_CLONED ) hb_xgrab( sizeof( HB_NESTED_CLONED ) );
pCloned->value = ( void * ) pBaseHash;
pCloned->pDest = pDstItem;
pCloned->pNext = pClonedList->pNext;
pClonedList->pNext = pCloned;
hb_hashCloneBody( pSrcItem, pDstItem, pClonedList );
}
}
else
hb_itemCopy( pDstItem, pSrcItem );
}
HB_EXPORT PHB_ITEM hb_arrayClone( PHB_ITEM pSrcArray )
{
PHB_ITEM pDstArray;
HB_TRACE(HB_TR_DEBUG, ("hb_arrayClone(%p)", pSrcArray));
pDstArray = hb_itemNew( NULL );
if( HB_IS_ARRAY( pSrcArray ) )
{
PHB_NESTED_CLONED pClonedList, pCloned;
PHB_BASEARRAY pSrcBaseArray = pSrcArray->item.asArray.value;
ULONG ulSrcLen = pSrcBaseArray->ulLen;
hb_arrayNew( pDstArray, ulSrcLen );
pClonedList = ( PHB_NESTED_CLONED ) hb_xgrab( sizeof( HB_NESTED_CLONED ) );
pClonedList->value = ( void * ) pSrcBaseArray;
pClonedList->pDest = pDstArray;
pClonedList->pNext = NULL;
hb_arrayCloneBody( pSrcBaseArray, pDstArray->item.asArray.value, pClonedList );
do
{
pCloned = pClonedList;
pClonedList = pClonedList->pNext;
hb_xfree( pCloned );
}
while( pClonedList );
}
return pDstArray;
}
HB_EXPORT PHB_ITEM hb_arrayFromStack( USHORT uiLen )
{
PHB_ITEM pArray = hb_itemNew( NULL );
USHORT uiPos;
HB_TRACE(HB_TR_DEBUG, ("hb_arrayFromStack(%hu)", uiLen));
hb_arrayNew( pArray, uiLen );
for( uiPos = 1; uiPos <= uiLen; uiPos++ )
{
hb_arraySet( pArray, uiPos, hb_stackItemFromTop( uiPos - uiLen - 1 ) );
}
return pArray;
}
PHB_ITEM hb_arrayFromParams( int iLevel )
{
PHB_ITEM pArray;
USHORT uiPos, uiPCount;
LONG lBaseOffset;
HB_TRACE(HB_TR_DEBUG, ("hb_arrayFromParams(%d)", iLevel));
lBaseOffset = hb_stackBaseProcOffset( iLevel );
if( lBaseOffset > 0 )
uiPCount = hb_stackItem( lBaseOffset )->item.asSymbol.paramcnt;
else
uiPCount = 0;
pArray = hb_itemArrayNew( uiPCount );
for( uiPos = 1; uiPos <= uiPCount; uiPos++ )
{
hb_arraySet( pArray, uiPos, hb_stackItem( lBaseOffset + uiPos + 1 ) );
}
return pArray;
}
HB_EXPORT PHB_ITEM hb_arrayBaseParams( void )
{
PHB_ITEM pArray;
USHORT uiPos, uiPCount;
HB_TRACE(HB_TR_DEBUG, ("hb_arrayBaseParams()"));
pArray = hb_itemNew( NULL );
uiPCount = hb_stackBaseItem()->item.asSymbol.paramcnt;
hb_arrayNew( pArray, uiPCount );
for( uiPos = 1; uiPos <= uiPCount; uiPos++ )
{
hb_arraySet( pArray, uiPos, hb_stackItemFromBase( uiPos ) );
}
return pArray;
}
HB_EXPORT PHB_ITEM hb_arraySelfParams( void )
{
PHB_ITEM pArray;
USHORT uiPos, uiPCount;
HB_TRACE(HB_TR_DEBUG, ("hb_arraySelfParams()"));
pArray = hb_itemNew( NULL );
uiPCount = hb_stackBaseItem()->item.asSymbol.paramcnt;
hb_arrayNew( pArray, uiPCount + 1 );
for( uiPos = 0; uiPos <= uiPCount; uiPos++ )
{
hb_arraySet( pArray, uiPos + 1, hb_stackItemFromBase( uiPos ) );
}
return pArray;
}
| arrays.c | 1186 |
arrayshb.c |
Type | Function | Source | Line |
STATIC VOID | hb_arrayNewRagged( PHB_ITEM pArray, int iDimension )
static void hb_arrayNewRagged( PHB_ITEM pArray, int iDimension )
{
ULONG ulElements;
HB_TRACE(HB_TR_DEBUG, ("hb_arrayNewRagged(%p, %d)", pArray, iDimension));
ulElements = ( ULONG ) hb_parnl( iDimension );
/* create an array */
hb_arrayNew( pArray, ulElements );
if( ++iDimension <= hb_pcount() )
{
/* call self recursively to create next dimensions
*/
while( ulElements )
hb_arrayNewRagged( hb_arrayGetItemPtr( pArray, ulElements-- ), iDimension );
}
}
| arrayshb.c | 59 |
HB_FUNC | ARRAY(void)
HB_FUNC( ARRAY )
{
int iPCount = hb_pcount();
if( iPCount > 0 )
{
BOOL bError = FALSE;
int iParam;
for( iParam = 1; iParam <= iPCount; iParam++ )
{
if( ! ISNUM( iParam ) )
{
bError = TRUE;
break;
}
if( hb_parnl( iParam ) < 0 ) /* || hb_parnl( iParam ) <= 4096 */
{
#ifdef HB_C52_STRICT
hb_errRT_BASE( EG_BOUND, 1131, NULL, hb_langDGetErrorDesc( EG_ARRDIMENSION ), 0 );
#else
hb_errRT_BASE( EG_BOUND, 1131, NULL, hb_langDGetErrorDesc( EG_ARRDIMENSION ), HB_ERR_ARGS_BASEPARAMS );
#endif
bError = TRUE;
break;
}
}
if( ! bError )
hb_arrayNewRagged( hb_stackReturnItem(), 1 );
}
}
| arrayshb.c | 82 |
HB_FUNC | AADD(void)
HB_FUNC( AADD )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray )
{
PHB_ITEM pValue = hb_param( 2, HB_IT_ANY );
if( pValue && hb_arrayAdd( pArray, pValue ) )
hb_itemReturn( pValue );
else
hb_errRT_BASE( EG_BOUND, 1187, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| arrayshb.c | 116 |
HB_FUNC | ASIZE(void)
HB_FUNC( ASIZE )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray && ISNUM( 2 ) )
{
long lSize = hb_parnl( 2 );
hb_arraySize( pArray, HB_MAX( lSize, 0 ) );
hb_itemReturn( pArray ); /* ASize() returns the array itself */
}
#ifdef HB_COMPAT_C53 /* From CA-Cl*pper 5.3a */
else
#ifdef HB_C52_STRICT
hb_errRT_BASE( EG_ARG, 2023, NULL, HB_ERR_FUNCNAME, 0 );
#else
hb_errRT_BASE( EG_ARG, 2023, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
#endif
#endif
}
| arrayshb.c | 136 |
HB_FUNC | ATAIL(void)
HB_FUNC( ATAIL )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray )
hb_arrayLast( pArray, hb_stackReturnItem() );
}
| arrayshb.c | 158 |
HB_FUNC | AINS(void)
HB_FUNC( AINS )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray )
{
long lPos = hb_parnl( 2 );
if( lPos == 0 )
lPos = 1;
hb_arrayIns( pArray, lPos );
hb_itemReturn( pArray ); /* AIns() returns the array itself */
}
}
| arrayshb.c | 166 |
HB_FUNC | ADEL(void)
HB_FUNC( ADEL )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray )
{
long lPos = hb_parnl( 2 );
if( lPos == 0 )
lPos = 1;
hb_arrayDel( pArray, lPos );
hb_itemReturn( pArray ); /* ADel() returns the array itself */
}
}
| arrayshb.c | 183 |
HB_FUNC | AFILL(void)
HB_FUNC( AFILL )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray )
{
PHB_ITEM pValue = hb_param( 2, HB_IT_ANY );
hb_itemReturn( pArray ); /* AFill() returns the array itself */
if( pValue )
{
ULONG ulStart, ulCount;
LONG lStart = hb_parnl( 3 ), lCount = hb_parnl( 4 );
/* Explicy lCount of 0 - Nothing to do! */
if( ISNUM( 4 ) && lCount == 0 )
return;
/* Clipper aborts if negative start. */
else if( lStart < 0 )
return;
/* Clipper allows Start to be of wrong type, or 0, and corrects it to 1. */
else if( lStart == 0 )
lStart = 1;
if( lCount < 0 )
{
/* Clipper allows the Count to be negative, if start is 1, and corrects it to maximum elements. */
if( lStart == 1 )
ulCount = 0;
/* Clipper aborts if negative count and start is not at 1. */
else
return;
}
ulStart = ( ULONG ) lStart;
ulCount = ( ULONG ) lCount;
hb_arrayFill( pArray,
pValue,
ISNUM( 3 ) ? &ulStart : NULL,
ISNUM( 4 ) ? &ulCount : NULL );
}
}
else
#ifdef HB_C52_STRICT
/* NOTE: In CA-Cl*pper AFILL() is written in a manner that it will
call AEVAL() to do the job, so the error (if any) will also be
thrown by AEVAL(). [vszakats] */
hb_errRT_BASE( EG_ARG, 2017, NULL, "AEVAL", 0 );
#else
hb_errRT_BASE( EG_ARG, 6004, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
#endif
}
| arrayshb.c | 200 |
HB_FUNC | ASCAN(void)
HB_FUNC( ASCAN )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
PHB_ITEM pValue = hb_param( 2, HB_IT_ANY );
if( pArray && pValue )
{
ULONG ulStart = hb_parnl( 3 );
ULONG ulCount = hb_parnl( 4 );
hb_retnint( hb_arrayScan( pArray, pValue,
ISNUM( 3 ) ? &ulStart : NULL,
ISNUM( 4 ) ? &ulCount : NULL,
FALSE ) );
}
else
hb_retni( 0 );
}
| arrayshb.c | 252 |
HB_FUNC | HB_ASCAN(void)
HB_FUNC( HB_ASCAN )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
PHB_ITEM pValue = hb_param( 2, HB_IT_ANY );
if( pArray && pValue )
{
ULONG ulStart = hb_parnl( 3 );
ULONG ulCount = hb_parnl( 4 );
hb_retnint( hb_arrayScan( pArray, pValue,
ISNUM( 3 ) ? &ulStart : NULL,
ISNUM( 4 ) ? &ulCount : NULL,
hb_parl( 5 ) ) );
}
else
hb_retni( 0 );
}
| arrayshb.c | 271 |
HB_FUNC | HB_RASCAN(void)
HB_FUNC( HB_RASCAN )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
PHB_ITEM pValue = hb_param( 2, HB_IT_ANY );
if( pArray && pValue )
{
ULONG ulStart = hb_parnl( 3 );
ULONG ulCount = hb_parnl( 4 );
hb_retnint( hb_arrayRevScan( pArray, pValue,
ISNUM( 3 ) ? &ulStart : NULL,
ISNUM( 4 ) ? &ulCount : NULL,
hb_parl( 5 ) ) );
}
else
hb_retni( 0 );
}
| arrayshb.c | 291 |
HB_FUNC | HB_AINS(void)
HB_FUNC( HB_AINS )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray )
{
long lPos = hb_parnl( 2 );
if( lPos == 0 )
lPos = 1;
if( hb_pcount() >= 4 && ISLOG( 4 ) && hb_parl( 4 ) )
{
ULONG ulLen = hb_arrayLen( pArray ) + 1;
if( lPos >= 1 && ( ULONG ) lPos <= ulLen )
hb_arraySize( pArray, ulLen );
}
if( hb_arrayIns( pArray, lPos ) )
{
if( hb_pcount() >= 3 && !ISNIL( 3 ) )
hb_arraySet( pArray, lPos, hb_param( 3, HB_IT_ANY ) );
}
hb_itemReturn( pArray ); /* AIns() returns the array itself */
}
}
| arrayshb.c | 310 |
HB_FUNC | HB_ADEL(void)
HB_FUNC( HB_ADEL )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray )
{
long lPos = hb_parnl( 2 );
if( lPos == 0 )
lPos = 1;
if( hb_arrayDel( pArray, lPos ) )
{
if( hb_pcount() >= 3 && ISLOG( 3 ) && hb_parl( 3 ) )
hb_arraySize( pArray, hb_arrayLen( pArray ) - 1 );
}
hb_itemReturn( pArray ); /* ADel() returns the array itself */
}
}
| arrayshb.c | 337 |
HB_FUNC | AEVAL(void)
HB_FUNC( AEVAL )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
PHB_ITEM pBlock = hb_param( 2, HB_IT_BLOCK );
if( pArray && pBlock )
{
ULONG ulStart = hb_parnl( 3 );
ULONG ulCount = hb_parnl( 4 );
hb_arrayEval( pArray,
pBlock,
ISNUM( 3 ) ? &ulStart : NULL,
ISNUM( 4 ) ? &ulCount : NULL );
hb_itemReturn( hb_stackItemFromBase( 1 ) ); /* AEval() returns the array itself */
}
else
hb_errRT_BASE( EG_ARG, 2017, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| arrayshb.c | 361 |
HB_FUNC | ACOPY(void)
HB_FUNC( ACOPY )
{
PHB_ITEM pSrcArray = hb_param( 1, HB_IT_ARRAY );
PHB_ITEM pDstArray = hb_param( 2, HB_IT_ARRAY );
if( pSrcArray && pDstArray )
{
/* CA-Cl*pper works this way. */
if( ! hb_arrayIsObject( pSrcArray ) && ! hb_arrayIsObject( pDstArray ) )
{
ULONG ulStart = hb_parnl( 3 );
ULONG ulCount = hb_parnl( 4 );
ULONG ulTarget = hb_parnl( 5 );
hb_arrayCopy( pSrcArray,
pDstArray,
ISNUM( 3 ) ? &ulStart : NULL,
ISNUM( 4 ) ? &ulCount : NULL,
ISNUM( 5 ) ? &ulTarget : NULL );
}
hb_itemReturn( hb_stackItemFromBase( 2 ) ); /* ACopy() returns the target array */
}
}
| arrayshb.c | 382 |
HB_FUNC | ACLONE(void)
HB_FUNC( ACLONE )
{
PHB_ITEM pSrcArray = hb_param( 1, HB_IT_ARRAY );
if( pSrcArray && ! hb_arrayIsObject( pSrcArray ) )
hb_itemReturnRelease( hb_arrayClone( pSrcArray ) ); /* AClone() returns the new array */
}
| arrayshb.c | 409 |
HB_FUNC | HB_APARAMS(void)
HB_FUNC( HB_APARAMS )
{
hb_itemReturnRelease( hb_arrayFromParams( hb_parni( 1 ) + 1 ) );
}
| arrayshb.c | 417 |
asort.c |
Type | Function | Source | Line |
STATIC BOOL | hb_itemIsLess( PHB_ITEM pItem1, PHB_ITEM pItem2, PHB_ITEM pBlock )
static BOOL hb_itemIsLess( PHB_ITEM pItem1, PHB_ITEM pItem2, PHB_ITEM pBlock )
{
if( pBlock )
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pBlock );
hb_vmPush( pItem1 );
hb_vmPush( pItem2 );
hb_vmSend( 2 );
if( HB_IS_LOGICAL( hb_stackReturnItem() ) )
return hb_itemGetL( hb_stackReturnItem() );
}
/* Do native compare when no codeblock is supplied */
if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) )
return hb_itemStrCmp( pItem1, pItem2, FALSE ) < 0;
else if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
return hb_itemGetNInt( pItem1 ) < hb_itemGetNInt( pItem2 );
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
return hb_itemGetND( pItem1 ) < hb_itemGetND( pItem2 );
else if( HB_IS_DATE( pItem1 ) && HB_IS_DATE( pItem2 ) )
return hb_itemGetDL( pItem1 ) < hb_itemGetDL( pItem2 );
else if( HB_IS_LOGICAL( pItem1 ) && HB_IS_LOGICAL( pItem2 ) )
return hb_itemGetL( pItem1 ) < hb_itemGetL( pItem2 );
else
{
/* NOTE: For non-matching types CA-Cl*pper sorts always like this:
Array/Object Block String Logical Date Numeric NIL [jlalin] */
int iWeight1;
int iWeight2;
if( HB_IS_ARRAY( pItem1 ) ) iWeight1 = 1;
else if( HB_IS_BLOCK( pItem1 ) ) iWeight1 = 2;
else if( HB_IS_STRING( pItem1 ) ) iWeight1 = 3;
else if( HB_IS_LOGICAL( pItem1 ) ) iWeight1 = 4;
else if( HB_IS_DATE( pItem1 ) ) iWeight1 = 5;
else if( HB_IS_NUMERIC( pItem1 ) ) iWeight1 = 6;
else iWeight1 = 7;
if( HB_IS_ARRAY( pItem2 ) ) iWeight2 = 1;
else if( HB_IS_BLOCK( pItem2 ) ) iWeight2 = 2;
else if( HB_IS_STRING( pItem2 ) ) iWeight2 = 3;
else if( HB_IS_LOGICAL( pItem2 ) ) iWeight2 = 4;
else if( HB_IS_DATE( pItem2 ) ) iWeight2 = 5;
else if( HB_IS_NUMERIC( pItem2 ) ) iWeight2 = 6;
else iWeight2 = 7;
return iWeight1 < iWeight2;
}
}
| asort.c | 66 |
STATIC LONG | hb_arraySortQuickPartition( PHB_ITEM pItems, LONG lb, LONG ub, PHB_ITEM pBlock )
static LONG hb_arraySortQuickPartition( PHB_ITEM pItems, LONG lb, LONG ub, PHB_ITEM pBlock )
{
LONG i, j, p;
/* select pivot and exchange with 1st element */
p = lb + ( ( ub - lb ) >> 1 );
if( p != lb )
{
hb_itemSwap( pItems + lb, pItems + p );
}
/* sort lb+1..ub based on pivot */
i = lb + 1;
j = ub;
while( TRUE )
{
while( i < j && hb_itemIsLess( pItems + i, pItems + lb, pBlock ) )
{
i++;
}
while( j >= i && hb_itemIsLess( pItems + lb, pItems + j, pBlock ) )
{
j--;
}
if( i >= j )
{
break;
}
/* Swap the items */
hb_itemSwap( pItems + i, pItems + j );
j--;
i++;
}
/* pivot belongs in pItems[j] */
if( j > lb )
{
hb_itemSwap( pItems + lb, pItems + j );
}
return j;
}
| asort.c | 122 |
STATIC VOID | hb_arraySortQuick( PHB_ITEM pItems, LONG lb, LONG ub, PHB_ITEM pBlock )
static void hb_arraySortQuick( PHB_ITEM pItems, LONG lb, LONG ub, PHB_ITEM pBlock )
{
while( lb < ub )
{
/* partition into two segments */
LONG m = hb_arraySortQuickPartition( pItems, lb, ub, pBlock );
/* sort the smallest partition to minimize stack requirements */
if( m - lb <= ub - m )
{
hb_arraySortQuick( pItems, lb, m - 1, pBlock );
lb = m + 1;
}
else
{
hb_arraySortQuick( pItems, m + 1, ub, pBlock );
ub = m - 1;
}
}
}
| asort.c | 171 |
BOOL | hb_arraySort( PHB_ITEM pArray, ULONG * pulStart, ULONG * pulCount, PHB_ITEM pBlock )
BOOL hb_arraySort( PHB_ITEM pArray, ULONG * pulStart, ULONG * pulCount, PHB_ITEM pBlock )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySort(%p, %p, %p, %p)", pArray, pulStart, pulCount, pBlock));
if( HB_IS_ARRAY( pArray ) )
{
PHB_BASEARRAY pBaseArray = pArray->item.asArray.value;
ULONG ulLen = pBaseArray->ulLen;
ULONG ulStart;
ULONG ulCount;
ULONG ulEnd;
if( pulStart && ( *pulStart >= 1 ) )
ulStart = *pulStart;
else
ulStart = 1;
if( ulStart <= ulLen )
{
if( pulCount && *pulCount >= 1 && ( *pulCount <= ulLen - ulStart ) )
ulCount = *pulCount;
else
ulCount = ulLen - ulStart + 1;
if( ulStart + ulCount > ulLen ) /* check range */
ulCount = ulLen - ulStart + 1;
ulEnd = ulCount + ulStart - 2;
/* Optimize when only one or no element is to be sorted */
if( ulCount > 1 )
hb_arraySortQuick( pBaseArray->pItems, ulStart - 1, ulEnd, pBlock );
}
return TRUE;
}
else
return FALSE;
}
| asort.c | 192 |
HB_FUNC | ASORT(void)
HB_FUNC( ASORT )
{
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray && ! hb_arrayIsObject( pArray ) )
{
ULONG ulStart = hb_parnl( 2 );
ULONG ulCount = hb_parnl( 3 );
hb_arraySort( pArray,
ISNUM( 2 ) ? &ulStart : NULL,
ISNUM( 3 ) ? &ulCount : NULL,
hb_param( 4, HB_IT_BLOCK ) );
hb_itemReturn( pArray ); /* ASort() returns the array itself */
}
}
| asort.c | 232 |
break.c |
Type | Function | Source | Line |
HB_FUNC | BREAK(void)
HB_FUNC( BREAK )
{
hb_vmRequestBreak( hb_param( 1, HB_IT_ANY ) );
}
| break.c | 62 |
classes.c |
Type | Function | Source | Line |
STATIC USHORT | hb_clsBucketPos( PHB_DYNS pMsg, USHORT uiMask )
static USHORT hb_clsBucketPos( PHB_DYNS pMsg, USHORT uiMask )
{
/*
* we can use PHB_DYNS address as base for hash key.
* This value is perfectly unique and we do not need anything more
* but it's not continuous so we will have to add dynamic BUCKETSIZE
* modification to be 100% sure that we can resolve all symbol name
* conflicts (though even without it it's rather theoretical problem).
* [druzus]
*/
/* Safely divide it by 16 - it's minimum memory allocated for single
* HB_DYNS structure
*/
/*
return ( ( USHORT ) ( ( HB_PTRDIFF ) pMsg >> 4 ) & uiMask ) << BUCKETBITS;
*/
/* Using continuous symbol numbers we are 100% sure that we will cover
* the whole 16bit area and we will never have any problems until number
* of symbols is limited to 2^16. [druzus]
*/
return ( pMsg->uiSymNum & uiMask ) << BUCKETBITS;
}
| classes.c | 363 |
STATIC BOOL | hb_clsDictRealloc( PCLASS pClass )
static BOOL hb_clsDictRealloc( PCLASS pClass )
{
ULONG ulNewHashKey, ulLimit, ul;
#ifdef HB_MSG_POOL
USHORT * puiMsgIdx;
#else
PMETHOD pNewMethods;
#endif
HB_TRACE(HB_TR_DEBUG, ("hb_clsDictRealloc(%p)", pClass));
ulNewHashKey = ( ULONG ) pClass->uiHashKey + 1;
ulLimit = ulNewHashKey << BUCKETBITS;
do
{
ulNewHashKey <<= 1;
if( ulNewHashKey > HASH_KEYMAX )
{
hb_errInternal( 6002, "Unable to realloc class message in __clsDictRealloc()", NULL, NULL );
return FALSE;
}
#ifdef HB_MSG_POOL
puiMsgIdx = ( USHORT * ) hb_xgrab( ( ulNewHashKey << BUCKETBITS ) * sizeof( USHORT ) );
memset( puiMsgIdx, 0, ( ulNewHashKey << BUCKETBITS ) * sizeof( USHORT ) );
for( ul = 0; ul < ulLimit; ul++ )
{
USHORT uiMsg = pClass->puiMsgIdx[ ul ];
if( pClass->puiMsgIdx[ ul ] )
{
USHORT uiBucket = BUCKETSIZE;
USHORT * puiIdx = puiMsgIdx + hb_clsBucketPos(
pClass->pMethods[ uiMsg ].pMessage, ulNewHashKey - 1 );
do
{
if( * puiIdx == 0 ) /* this message position is empty */
{
* puiIdx = uiMsg;
break;
}
++puiIdx;
} while( --uiBucket );
/* Not enough go back to the beginning */
if( ! uiBucket )
{
hb_xfree( puiMsgIdx );
break;
}
}
}
}
while( ul < ulLimit );
pClass->uiHashKey = ( USHORT ) ( ulNewHashKey - 1 );
hb_xfree( pClass->puiMsgIdx );
pClass->puiMsgIdx = puiMsgIdx;
#else
pNewMethods = ( PMETHOD ) hb_xgrab( ( ulNewHashKey << BUCKETBITS ) * sizeof( METHOD ) );
memset( pNewMethods, 0, ( ulNewHashKey << BUCKETBITS ) * sizeof( METHOD ) );
for( ul = 0; ul < ulLimit; ul++ )
{
PHB_DYNS pMessage = ( PHB_DYNS ) pClass->pMethods[ ul ].pMessage;
if( pMessage )
{
PMETHOD pMethod = pNewMethods + hb_clsBucketPos( pMessage, ulNewHashKey - 1 );
USHORT uiBucket = BUCKETSIZE;
do
{
if( ! pMethod->pMessage ) /* this message position is empty */
{
memcpy( pMethod, pClass->pMethods + ul, sizeof( METHOD ) );
break;
}
++pMethod;
} while( --uiBucket );
/* Not enough go back to the beginning */
if( ! uiBucket )
{
hb_xfree( pNewMethods );
break;
}
}
}
}
while( ul < ulLimit );
pClass->uiHashKey = ( USHORT ) ( ulNewHashKey - 1 );
hb_xfree( pClass->pMethods );
pClass->pMethods = pNewMethods;
#endif
return TRUE;
}
| classes.c | 389 |
} STATIC VOID | hb_clsDictInit( PCLASS pClass, USHORT uiHashKey )
static void hb_clsDictInit( PCLASS pClass, USHORT uiHashKey )
{
ULONG ulSize;
HB_TRACE(HB_TR_DEBUG, ("hb_clsDictInit(%p,%hu)", pClass, uiHashKey));
pClass->uiHashKey = uiHashKey;
#ifdef HB_MSG_POOL
ulSize = ( ( ( ULONG ) uiHashKey + 1 ) << BUCKETBITS ) * sizeof( USHORT );
pClass->puiMsgIdx = ( USHORT * ) hb_xgrab( ulSize );
memset( pClass->puiMsgIdx, 0, ulSize );
pClass->uiMethodCount = 1;
pClass->pMethods = ( PMETHOD ) hb_xgrab( sizeof( METHOD ) );
memset( pClass->pMethods, 0, sizeof( METHOD ) );
#else
ulSize = ( ( ( ULONG ) uiHashKey + 1 ) << BUCKETBITS ) * sizeof( METHOD );
pClass->pMethods = ( PMETHOD ) hb_xgrab( ulSize );
memset( pClass->pMethods, 0, ulSize );
#endif
}
| classes.c | 497 |
STATIC PMETHOD | hb_clsFindMsg( PCLASS pClass, PHB_DYNS pMsg )
static PMETHOD hb_clsFindMsg( PCLASS pClass, PHB_DYNS pMsg )
{
#ifdef HB_MSG_POOL
USHORT uiBucket, * puiMsgIdx;
HB_TRACE(HB_TR_DEBUG, ("hb_clsFindMsg(%p,%p)", pClass, pMsg));
puiMsgIdx = pClass->puiMsgIdx + hb_clsBucketPos( pMsg, pClass->uiHashKey );
uiBucket = BUCKETSIZE;
do
{
if( pClass->pMethods[ * puiMsgIdx ].pMessage == pMsg )
{
return &pClass->pMethods[ * puiMsgIdx ];
}
++puiMsgIdx;
}
while( --uiBucket );
#else
PMETHOD pMethod;
USHORT uiBucket;
HB_TRACE(HB_TR_DEBUG, ("hb_clsFindMsg(%p,%p)", pClass, pMsg));
pMethod = pClass->pMethods + hb_clsBucketPos( pMsg, pClass->uiHashKey );
uiBucket = BUCKETSIZE;
do
{
if( pMethod->pMessage == pMsg )
return pMethod;
++pMethod;
}
while( --uiBucket );
#endif
return NULL;
}
| classes.c | 519 |
STATIC PMETHOD | hb_clsAllocMsg( PCLASS pClass, PHB_DYNS pMsg )
static PMETHOD hb_clsAllocMsg( PCLASS pClass, PHB_DYNS pMsg )
{
HB_TRACE(HB_TR_DEBUG, ("hb_clsAllocMsg(%p,%p)", pClass, pMsg));
do
{
#ifdef HB_MSG_POOL
USHORT uiBucket = BUCKETSIZE, * puiMsgIdx = pClass->puiMsgIdx +
hb_clsBucketPos( pMsg, pClass->uiHashKey );
do
{
if( * puiMsgIdx == 0 )
{
pClass->pMethods = ( PMETHOD ) hb_xrealloc( pClass->pMethods,
sizeof( METHOD ) * ( pClass->uiMethodCount + 1 ) );
memset( &pClass->pMethods[ pClass->uiMethodCount ], 0, sizeof( METHOD ) );
* puiMsgIdx = pClass->uiMethodCount++;
return &pClass->pMethods[ * puiMsgIdx ];
}
else if( pClass->pMethods[ * puiMsgIdx ].pMessage == pMsg )
return &pClass->pMethods[ * puiMsgIdx ];
++puiMsgIdx;
}
while( --uiBucket );
#else
PMETHOD pMethod = pClass->pMethods + hb_clsBucketPos( pMsg, pClass->uiHashKey );
USHORT uiBucket = BUCKETSIZE;
do
{
if( ! pMethod->pMessage || pMethod->pMessage == pMsg )
return pMethod;
++pMethod;
}
while( --uiBucket );
#endif
}
while( hb_clsDictRealloc( pClass ) );
return NULL;
}
| classes.c | 562 |
STATIC BOOL | hb_clsCanClearMethod( PMETHOD pMethod, BOOL fError )
static BOOL hb_clsCanClearMethod( PMETHOD pMethod, BOOL fError )
{
HB_SYMBOL_UNUSED( pMethod );
HB_SYMBOL_UNUSED( fError );
#if 0
if( pMethod->pFuncSym == &s___msgSuper )
{
if( fError )
hb_errRT_BASE( EG_ARG, 3000, "Cannot delete supercast messages", HB_ERR_FUNCNAME, 0 );
return FALSE;
}
#endif
return TRUE;
}
| classes.c | 611 |
STATIC VOID | hb_clsFreeMsg( PCLASS pClass, PHB_DYNS pMsg )
static void hb_clsFreeMsg( PCLASS pClass, PHB_DYNS pMsg )
{
#ifdef HB_MSG_POOL
USHORT uiBucket, * puiMsgIdx;
HB_TRACE(HB_TR_DEBUG, ("hb_clsFreeMsg(%p,%p)", pClass, pMsg));
puiMsgIdx = pClass->puiMsgIdx + hb_clsBucketPos( pMsg, pClass->uiHashKey );
uiBucket = BUCKETSIZE;
do
{
if( * puiMsgIdx && pClass->pMethods[ * puiMsgIdx ].pMessage == pMsg )
{
if( hb_clsCanClearMethod( &pClass->pMethods[ * puiMsgIdx ], TRUE ) )
{
memset( &pClass->pMethods[ * puiMsgIdx ], 0, sizeof( METHOD ) );
* puiMsgIdx = 0;
pClass->uiMethods--; /* Decrease number of messages */
}
return;
}
++puiMsgIdx;
}
while( --uiBucket );
#else
PMETHOD pMethod;
USHORT uiBucket;
HB_TRACE(HB_TR_DEBUG, ("hb_clsFreeMsg(%p,%p)", pClass, pMsg));
pMethod = pClass->pMethods + hb_clsBucketPos( pMsg, pClass->uiHashKey );
uiBucket = BUCKETSIZE;
do
{
if( pMethod->pMessage == pMsg )
{
if( hb_clsCanClearMethod( pMethod, TRUE ) )
{
/* Move messages */
while( --uiBucket )
{
memcpy( pMethod, pMethod + 1, sizeof( METHOD ) );
pMethod++;
}
memset( pMethod, 0, sizeof( METHOD ) );
pClass->uiMethods--; /* Decrease number of messages */
}
return;
}
++pMethod;
}
while( --uiBucket );
#endif
}
| classes.c | 626 |
STATIC BOOL | hb_clsHasParent( PCLASS pClass, PHB_DYNS pParentSym )
static BOOL hb_clsHasParent( PCLASS pClass, PHB_DYNS pParentSym )
{
PMETHOD pMethod = hb_clsFindMsg( pClass, pParentSym );
return pMethod && pMethod->pFuncSym == &s___msgSuper;
}
| classes.c | 688 |
STATIC USHORT | hb_clsParentInstanceOffset( PCLASS pClass, PHB_DYNS pParentSym )
static USHORT hb_clsParentInstanceOffset( PCLASS pClass, PHB_DYNS pParentSym )
{
PMETHOD pMethod = hb_clsFindMsg( pClass, pParentSym );
return ( pMethod && pMethod->pFuncSym == &s___msgSuper ) ? pMethod->uiOffset : 0;
}
| classes.c | 695 |
STATIC USHORT | hb_clsAddInitValue( PCLASS pClass, PHB_ITEM pItem, USHORT uiType, USHORT uiData, USHORT uiOffset, USHORT uiSprClass )
static USHORT hb_clsAddInitValue( PCLASS pClass, PHB_ITEM pItem,
USHORT uiType, USHORT uiData,
USHORT uiOffset, USHORT uiSprClass )
{
PINITDATA pInitData;
HB_TRACE(HB_TR_DEBUG, ("hb_clsAddInitValue(%p,%p,%hu,%hu,%hu,%hu)", pClass, pItem, uiType, uiData, uiOffset, uiSprClass));
if( ! pItem || HB_IS_NIL( pItem ) )
return 0;
if( ! pClass->uiInitDatas )
{
pClass->pInitData = ( PINITDATA ) hb_xgrab( sizeof( INITDATA ) );
pInitData = pClass->pInitData + pClass->uiInitDatas++;
}
else
{
USHORT ui = pClass->uiInitDatas;
pInitData = pClass->pInitData;
do
{
if( pInitData->uiType == uiType &&
pInitData->uiData + pInitData->uiOffset == uiData + uiOffset )
{
hb_itemRelease( pInitData->pInitValue );
break;
}
++pInitData;
}
while( --ui );
if( ui == 0 )
{
pClass->pInitData = ( PINITDATA ) hb_xrealloc( pClass->pInitData,
( ULONG ) ( pClass->uiInitDatas + 1 ) * sizeof( INITDATA ) );
pInitData = pClass->pInitData + pClass->uiInitDatas++;
}
}
pInitData->pInitValue = hb_itemClone( pItem );
pInitData->uiType = uiType;
pInitData->uiData = uiData;
pInitData->uiOffset = uiOffset;
pInitData->uiSprClass = uiSprClass;
return pClass->uiInitDatas;
}
| classes.c | 702 |
STATIC USHORT | hb_clsFindRealClassDataOffset( PMETHOD pMethod )
static USHORT hb_clsFindRealClassDataOffset( PMETHOD pMethod )
{
PMETHOD pRealMth;
HB_TRACE(HB_TR_DEBUG, ("hb_clsFindRealClassDataOffset(%p)", pMethod));
pRealMth = hb_clsFindMsg( &s_pClasses[ pMethod->uiSprClass ],
pMethod->pMessage );
if( pRealMth && pRealMth->uiSprClass == pMethod->uiSprClass &&
( pRealMth->pFuncSym == &s___msgSetClsData ||
pRealMth->pFuncSym == &s___msgGetClsData ) )
{
return pRealMth->uiData;
}
return 0;
}
| classes.c | 751 |
STATIC USHORT | hb_clsFindClassDataOffset( PCLASS pClass, PMETHOD pNewMethod )
static USHORT hb_clsFindClassDataOffset( PCLASS pClass, PMETHOD pNewMethod )
{
USHORT uiData;
HB_TRACE(HB_TR_DEBUG, ("hb_clsFindClassDataOffset(%p,%p)", pClass, pNewMethod));
uiData = hb_clsFindRealClassDataOffset( pNewMethod );
if( uiData )
{
ULONG ulLimit = hb_clsMthNum( pClass );
PMETHOD pMethod = pClass->pMethods;
do
{
if( pMethod->pMessage && pMethod != pNewMethod &&
pMethod->uiSprClass == pNewMethod->uiSprClass &&
( pMethod->pFuncSym == &s___msgSetClsData ||
pMethod->pFuncSym == &s___msgGetClsData ) &&
uiData == hb_clsFindRealClassDataOffset( pMethod ) )
{
return pMethod->uiData;
}
++pMethod;
}
while( --ulLimit );
}
return 0;
}
| classes.c | 768 |
STATIC BOOL | hb_clsUpdateHiddenMessages( PMETHOD pSrcMethod, PMETHOD pDstMethod, PCLASS pDstClass )
static BOOL hb_clsUpdateHiddenMessages( PMETHOD pSrcMethod, PMETHOD pDstMethod,
PCLASS pDstClass )
{
PMETHOD pNewMethod = pSrcMethod;
HB_TRACE(HB_TR_DEBUG, ("hb_clsUpdateHiddenMessages(%p,%p,%p)", pSrcMethod, pDstMethod, pDstClass));
if( ! pDstMethod->pMessage ||
( hb_clsCanClearMethod( pDstMethod, FALSE ) &&
pDstMethod->uiPrevCls != pDstMethod->uiSprClass &&
( pDstMethod->uiScope & HB_OO_CLSTP_HIDDEN ) &&
( pDstMethod->uiScope & HB_OO_CLSTP_NONVIRTUAL ) ) )
{
while( pNewMethod &&
pNewMethod->uiPrevCls != pNewMethod->uiSprClass &&
( pNewMethod->uiScope & HB_OO_CLSTP_HIDDEN ) &&
( pNewMethod->uiScope & HB_OO_CLSTP_NONVIRTUAL ) )
{
pNewMethod = hb_clsFindMsg( &s_pClasses[ pNewMethod->uiPrevCls ],
pNewMethod->pMessage );
}
if( pNewMethod && pNewMethod != pSrcMethod &&
!( pNewMethod->uiScope & HB_OO_CLSTP_HIDDEN ) &&
hb_clsCanClearMethod( pDstMethod, FALSE ) )
{
USHORT uiPrevCls = pDstMethod->uiPrevCls,
uiPrevMth = pDstMethod->uiPrevMth;
memcpy( pDstMethod, pNewMethod, sizeof( METHOD ) );
pDstMethod->uiPrevCls = uiPrevCls;
pDstMethod->uiPrevMth = uiPrevMth;
pDstMethod->uiScope |= HB_OO_CLSTP_OVERLOADED | HB_OO_CLSTP_SUPER;
if( pDstMethod->pFuncSym == &s___msgSetData ||
pDstMethod->pFuncSym == &s___msgGetData )
{
pDstMethod->uiOffset = hb_clsParentInstanceOffset( pDstClass,
s_pClasses[ pDstMethod->uiSprClass ].pClassSym );
}
else if( pDstMethod->pFuncSym == &s___msgSetClsData ||
pDstMethod->pFuncSym == &s___msgGetClsData )
{
PCLASS pSrcClass = &s_pClasses[ pDstMethod->uiSprClass ];
USHORT uiData;
uiData = hb_clsFindClassDataOffset( pDstClass, pDstMethod );
if( uiData == 0 )
{
uiData = ( USHORT ) hb_arrayLen( pDstClass->pClassDatas ) + 1;
hb_arraySize( pDstClass->pClassDatas, uiData );
}
if( pDstMethod->uiOffset )
{
pDstMethod->uiOffset = hb_clsAddInitValue( pDstClass,
pSrcClass->pInitData[ pDstMethod->uiOffset - 1 ].pInitValue,
HB_OO_MSG_CLASSDATA, uiData, 0, pDstMethod->uiSprClass );
}
pDstMethod->uiData = uiData;
}
return TRUE;
}
}
return FALSE;
}
| classes.c | 797 |
STATIC VOID | hb_clsCopyClass( PCLASS pClsDst, PCLASS pClsSrc )
static void hb_clsCopyClass( PCLASS pClsDst, PCLASS pClsSrc )
{
PMETHOD pMethod;
ULONG ulLimit;
HB_TRACE(HB_TR_DEBUG, ("hb_clsCopyClass(%p,%p)", pClsDst, pClsSrc));
hb_clsDictInit( pClsDst, pClsSrc->uiHashKey );
pClsDst->fHasOnError = pClsSrc->fHasOnError;
pClsDst->fHasDestructor = pClsSrc->fHasDestructor;
/* CLASS DATA Not Shared ( new array, new value ) */
pClsDst->pClassDatas = hb_arrayClone( pClsSrc->pClassDatas );
/* do not copy shared data array - just simply create new one */
pClsDst->pSharedDatas = hb_itemArrayNew( 0 );
pClsDst->pInlines = hb_arrayClone( pClsSrc->pInlines );
pClsDst->uiDatas = pClsSrc->uiDatas;
pClsDst->ulOpFlags = pClsSrc->ulOpFlags;
if( pClsSrc->uiInitDatas )
{
ULONG ulSize = ( ULONG ) pClsSrc->uiInitDatas * sizeof( INITDATA );
USHORT uiData;
pClsDst->uiInitDatas = pClsSrc->uiInitDatas;
pClsDst->pInitData = ( PINITDATA ) hb_xgrab( ulSize );
memcpy( pClsDst->pInitData, pClsSrc->pInitData, ulSize );
for( uiData = 0; uiData < pClsDst->uiInitDatas; ++uiData )
{
if( pClsDst->pInitData[ uiData ].uiType == HB_OO_MSG_INITIALIZED )
pClsDst->pInitData[ uiData ].uiType = HB_OO_MSG_CLASSDATA;
pClsDst->pInitData[ uiData ].pInitValue =
hb_itemNew( pClsDst->pInitData[ uiData ].pInitValue );
}
}
ulLimit = hb_clsMthNum( pClsSrc );
#ifdef HB_MSG_POOL
memcpy( pClsDst->puiMsgIdx, pClsSrc->puiMsgIdx,
( ( ( ULONG ) pClsSrc->uiHashKey + 1 ) << BUCKETBITS ) * sizeof( USHORT ) );
pClsDst->uiMethodCount = pClsSrc->uiMethodCount;
pClsDst->pMethods = ( PMETHOD ) hb_xrealloc( pClsDst->pMethods,
ulLimit * sizeof( METHOD ) );
#endif
memcpy( pClsDst->pMethods, pClsSrc->pMethods, ulLimit * sizeof( METHOD ) );
pClsDst->uiMethods = pClsSrc->uiMethods;
pMethod = pClsDst->pMethods;
do
{
if( pMethod->pMessage )
{
hb_clsUpdateHiddenMessages( pMethod, pMethod, pClsDst );
pMethod->uiScope |= HB_OO_CLSTP_SUPER;
}
++pMethod;
}
while( --ulLimit );
}
| classes.c | 863 |
STATIC BOOL | hb_clsIsFriendSymbol( PCLASS pClass, PHB_SYMB pSym )
static BOOL hb_clsIsFriendSymbol( PCLASS pClass, PHB_SYMB pSym )
{
USHORT uiCount;
HB_TRACE(HB_TR_DEBUG, ("hb_clsIsFriendSymbol(%p,%p)", pClass, pSym));
if( pSym >= pClass->pFriendModule &&
pSym < pClass->pFriendModule + pClass->uiFriendModule )
return TRUE;
for( uiCount = 0; uiCount < pClass->uiFriendSyms; ++uiCount )
{
if( pClass->pFriendSyms[ uiCount ] == pSym )
return TRUE;
}
return FALSE;
}
| classes.c | 923 |
STATIC VOID | hb_clsAddFriendSymbol( PCLASS pClass, PHB_SYMB pSym )
static void hb_clsAddFriendSymbol( PCLASS pClass, PHB_SYMB pSym )
{
HB_TRACE(HB_TR_DEBUG, ("hb_clsAddFriendSymbol(%p,%p)", pClass, pSym));
if( ! hb_clsIsFriendSymbol( pClass, pSym ) )
{
if( pClass->uiFriendSyms == 0 )
{
pClass->pFriendSyms = ( PHB_SYMB * ) hb_xgrab( sizeof( PHB_SYMB ) );
pClass->pFriendSyms[ 0 ] = pSym;
pClass->uiFriendSyms++;
}
else
{
pClass->pFriendSyms = ( PHB_SYMB * ) hb_xrealloc( pClass->pFriendSyms,
( pClass->uiFriendSyms + 1 ) * sizeof( PHB_SYMB ) );
pClass->pFriendSyms[ pClass->uiFriendSyms++ ] = pSym;
}
}
}
| classes.c | 942 |
VOID | hb_clsInit( void )
void hb_clsInit( void )
{
PHB_SYMB pOpSym;
USHORT uiOperator;
HB_TRACE(HB_TR_DEBUG, ("hb_clsInit()"));
for( uiOperator = 0, pOpSym = s_opSymbols; uiOperator <= HB_OO_MAX_OPERATOR;
++uiOperator, ++pOpSym )
{
pOpSym->pDynSym = hb_dynsymGetCase( pOpSym->szName );
}
s___msgDestructor.pDynSym = hb_dynsymGetCase( s___msgDestructor.szName );
s___msgOnError.pDynSym = hb_dynsymGetCase( s___msgOnError.szName );
s___msgClassName.pDynSym = hb_dynsymGetCase( s___msgClassName.szName ); /* Standard messages */
s___msgClassH.pDynSym = hb_dynsymGetCase( s___msgClassH.szName ); /* Not present in classdef. */
s___msgClassSel.pDynSym = hb_dynsymGetCase( s___msgClassSel.szName );
s___msgExec.pDynSym = hb_dynsymGetCase( s___msgExec.szName );
s___msgName.pDynSym = hb_dynsymGetCase( s___msgName.szName );
s___msgNew.pDynSym = hb_dynsymGetCase( s___msgNew.szName );
s___msgSymbol.pDynSym = hb_dynsymGetCase( s___msgSymbol.szName );
s___msgKeys.pDynSym = hb_dynsymGetCase( s___msgKeys.szName );
s___msgValues.pDynSym = hb_dynsymGetCase( s___msgValues.szName );
/*
s___msgClsParent.pDynSym = hb_dynsymGetCase( s___msgClsParent.szName );
s___msgClass.pDynSym = hb_dynsymGetCase( s___msgClass.szName );
*/
s___msgEnumIndex.pDynSym = hb_dynsymGetCase( s___msgEnumIndex.szName );
s___msgEnumBase.pDynSym = hb_dynsymGetCase( s___msgEnumBase.szName );
s___msgEnumKey.pDynSym = hb_dynsymGetCase( s___msgEnumKey.szName );
s___msgEnumValue.pDynSym = hb_dynsymGetCase( s___msgEnumValue.szName );
s___msgWithObjectPush.pDynSym = hb_dynsymGetCase( s___msgWithObjectPush.szName );
s___msgWithObjectPop.pDynSym = hb_dynsymGetCase( s___msgWithObjectPop.szName );
}
| classes.c | 963 |
VOID | hb_clsDoInit( void )
void hb_clsDoInit( void )
{
static const char * s_pszFuncNames[] =
{ "HBARRAY", "HBBLOCK", "HBCHARACTER", "HBDATE",
"HBHASH", "HBLOGICAL", "HBNIL", "HBNUMERIC",
"HBSYMBOL", "HBPOINTER" };
static USHORT * s_puiHandles[] =
{ &s_uiArrayClass, &s_uiBlockClass, &s_uiCharacterClass, &s_uiDateClass,
&s_uiHashClass, &s_uiLogicalClass, &s_uiNilClass, &s_uiNumericClass,
&s_uiSymbolClass, &s_uiPointerClass };
int i;
HB_TRACE(HB_TR_DEBUG, ("hb_clsDoInit()"));
for( i = 0; i < ( int ) ( sizeof( s_puiHandles ) / sizeof( USHORT * ) ); ++i )
{
PHB_DYNS pFuncSym = hb_dynsymFindName( s_pszFuncNames[i] );
if( pFuncSym && hb_dynsymIsFunction( pFuncSym ) )
{
PHB_ITEM pObject;
hb_vmPushDynSym( pFuncSym );
hb_vmPushNil();
hb_vmDo( 0 );
pObject = hb_stackReturnItem();
if( HB_IS_OBJECT( pObject ) )
*( s_puiHandles[i] ) = pObject->item.asArray.value->uiClass;
}
}
}
| classes.c | 1004 |
STATIC VOID | hb_clsRelease( PCLASS pClass )
static void hb_clsRelease( PCLASS pClass )
{
HB_TRACE(HB_TR_DEBUG, ("hb_clsRelease(%p)", pClass));
if( pClass->uiInitDatas )
{
USHORT ui = pClass->uiInitDatas;
PINITDATA pInitData = pClass->pInitData;
do
{
hb_itemRelease( pInitData->pInitValue );
++pInitData;
}
while( --ui );
hb_xfree( pClass->pInitData );
}
if( pClass->szName )
hb_xfree( pClass->szName );
if( pClass->pMethods )
hb_xfree( pClass->pMethods );
if( pClass->uiFriendSyms )
hb_xfree( pClass->pFriendSyms );
#ifdef HB_MSG_POOL
if( pClass->puiMsgIdx )
hb_xfree( pClass->puiMsgIdx );
#endif
if( pClass->pClassDatas )
hb_itemRelease( pClass->pClassDatas );
if( pClass->pSharedDatas )
hb_itemRelease( pClass->pSharedDatas );
if( pClass->pInlines )
hb_itemRelease( pClass->pInlines );
}
| classes.c | 1037 |
VOID | hb_clsReleaseAll( void )
void hb_clsReleaseAll( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_clsReleaseAll()"));
if( s_uiClasses )
{
USHORT uiClass = s_uiClasses;
/* It blocks destructor execution - don't move. [druzus] */
s_uiClasses = 0;
do
{
hb_clsRelease( &s_pClasses[ uiClass ] );
}
while( --uiClass );
hb_xfree( s_pClasses );
s_pClasses = NULL;
}
}
| classes.c | 1079 |
VOID | hb_clsIsClassRef( void )
void hb_clsIsClassRef( void )
{
/*
* All internal items are allocated with hb_itemNew()
* GC knows them and scan itself so it's not necessary
* to repeat scanning here [druzus].
*/
#if 0
USHORT uiClass = s_uiClasses;
PCLASS pClass = s_pClasses + 1;
HB_TRACE(HB_TR_DEBUG, ("hb_clsIsClassRef()"));
while( uiClass-- )
{
if( pClass->pInlines )
hb_gcItemRef( pClass->pInlines );
if( pClass->pClassDatas )
hb_gcItemRef( pClass->pClassDatas );
if( pClass->pSharedDatas )
hb_gcItemRef( pClass->pSharedDatas );
if( pClass->uiInitDatas )
{
USHORT ui = pClass->uiInitDatas;
PINITDATA pInitData = pClass->pInitData;
do
{
if( HB_IS_GCITEM( pInitData->pInitValue ) )
hb_gcItemRef( pInitData->pInitValue );
++pInitData;
}
while( --ui );
}
++pClass;
}
#endif
}
| classes.c | 1110 |
HB_EXPORT BOOL | hb_clsIsParent( USHORT uiClass, const char * szParentName )
HB_EXPORT BOOL hb_clsIsParent( USHORT uiClass, const char * szParentName )
{
if( uiClass && uiClass <= s_uiClasses )
{
PCLASS pClass = &s_pClasses[ uiClass ];
if( strcmp( pClass->szName, szParentName ) == 0 )
return TRUE;
else
{
PHB_DYNS pMsg = hb_dynsymFindName( szParentName );
if( pMsg )
return hb_clsHasParent( &s_pClasses[ uiClass ], pMsg );
}
}
return FALSE;
}
| classes.c | 1152 |
HB_EXPORT USHORT | hb_objGetClass( PHB_ITEM pItem )
HB_EXPORT USHORT hb_objGetClass( PHB_ITEM pItem )
{
if( pItem && HB_IS_ARRAY( pItem ) )
return pItem->item.asArray.value->uiClass;
else
return 0;
}
| classes.c | 1172 |
HB_EXPORT USHORT | hb_objSetClass( PHB_ITEM pItem, const char * szClass, const char * szFunc )
HB_EXPORT USHORT hb_objSetClass( PHB_ITEM pItem, const char * szClass, const char * szFunc )
{
USHORT uiClass = 0;
if( pItem && HB_IS_ARRAY( pItem ) &&
pItem->item.asArray.value->uiClass == 0 )
{
uiClass = pItem->item.asArray.value->uiClass =
hb_clsFindClass( szClass, szFunc );
}
return uiClass;
}
| classes.c | 1180 |
STATIC USHORT | hb_objGetClassH( PHB_ITEM pObject )
static USHORT hb_objGetClassH( PHB_ITEM pObject )
{
HB_TRACE(HB_TR_DEBUG, ("hb_objGetClassH(%p)", pObject));
if( HB_IS_ARRAY( pObject ) )
{
if( pObject->item.asArray.value->uiClass != 0 )
return pObject->item.asArray.value->uiClass;
else
return s_uiArrayClass;
}
/* built in types */
else if( HB_IS_NIL( pObject ) )
return s_uiNilClass;
else if( HB_IS_STRING( pObject ) )
return s_uiCharacterClass;
else if( HB_IS_NUMERIC( pObject ) )
return s_uiNumericClass;
else if( HB_IS_DATE( pObject ) )
return s_uiDateClass;
else if( HB_IS_LOGICAL( pObject ) )
return s_uiLogicalClass;
else if( HB_IS_BLOCK( pObject ) )
return s_uiBlockClass;
else if( HB_IS_HASH( pObject ) )
return s_uiHashClass;
else if( HB_IS_POINTER( pObject ) )
return s_uiPointerClass;
else if( HB_IS_SYMBOL( pObject ) )
return s_uiSymbolClass;
return 0;
}
| classes.c | 1196 |
HB_EXPORT CONST CHAR * | hb_objGetClsName( PHB_ITEM pObject )
HB_EXPORT const char * hb_objGetClsName( PHB_ITEM pObject )
{
HB_TRACE(HB_TR_DEBUG, ("hb_objGetClsName(%p)", pObject));
if( HB_IS_ARRAY( pObject ) )
{
if( pObject->item.asArray.value->uiClass != 0 )
return s_pClasses[ pObject->item.asArray.value->uiClass ].szName;
else
return "ARRAY";
}
/* built in types */
else if( HB_IS_NIL( pObject ) )
return "NIL";
else if( HB_IS_STRING( pObject ) )
return "CHARACTER";
else if( HB_IS_NUMERIC( pObject ) )
return "NUMERIC";
else if( HB_IS_DATE( pObject ) )
return "DATE";
else if( HB_IS_LOGICAL( pObject ) )
return "LOGICAL";
else if( HB_IS_BLOCK( pObject ) )
return "BLOCK";
else if( HB_IS_HASH( pObject ) )
return "HASH";
else if( HB_IS_POINTER( pObject ) )
return "POINTER";
else if( HB_IS_SYMBOL( pObject ) )
return "SYMBOL";
else
return "UNKNOWN";
}
| classes.c | 1241 |
HB_EXPORT CONST CHAR * | hb_clsName( USHORT uiClass )
HB_EXPORT const char * hb_clsName( USHORT uiClass )
{
if( uiClass && uiClass <= s_uiClasses )
return s_pClasses[ uiClass ].szName;
else
return NULL;
}
| classes.c | 1287 |
HB_EXPORT CONST CHAR * | hb_clsFuncName( USHORT uiClass )
HB_EXPORT const char * hb_clsFuncName( USHORT uiClass )
{
if( uiClass && uiClass <= s_uiClasses )
return s_pClasses[ uiClass ].pClassFuncSym ?
s_pClasses[ uiClass ].pClassFuncSym->szName :
"";
else
return NULL;
}
| classes.c | 1295 |
HB_EXPORT USHORT | hb_clsFindClass( const char * szClass, const char * szFunc )
HB_EXPORT USHORT hb_clsFindClass( const char * szClass, const char * szFunc )
{
USHORT uiClass;
for( uiClass = 1; uiClass <= s_uiClasses; uiClass++ )
{
if( strcmp( szClass, s_pClasses[ uiClass ].szName ) == 0 &&
( !szFunc || ( !s_pClasses[ uiClass ].pClassFuncSym ? !*szFunc :
strcmp( szFunc, s_pClasses[ uiClass ].pClassFuncSym->szName ) == 0 ) ) )
{
return uiClass;
}
}
return 0;
}
| classes.c | 1305 |
STATIC USHORT | hb_clsFindClassByFunc( PHB_SYMB pClassFuncSym )
static USHORT hb_clsFindClassByFunc( PHB_SYMB pClassFuncSym )
{
USHORT uiClass;
for( uiClass = 1; uiClass <= s_uiClasses; uiClass++ )
{
if( s_pClasses[ uiClass ].pClassFuncSym == pClassFuncSym )
{
return uiClass;
}
}
return 0;
}
| classes.c | 1321 |
HB_EXPORT CONST CHAR * | hb_objGetRealClsName( PHB_ITEM pObject, const char * szName )
HB_EXPORT const char * hb_objGetRealClsName( PHB_ITEM pObject, const char * szName )
{
USHORT uiClass;
HB_TRACE(HB_TR_DEBUG, ("hb_objGetrealClsName(%p,%s)", pObject, szName));
uiClass = hb_objGetClassH( pObject );
if( uiClass && uiClass <= uiClass )
{
PHB_DYNS pMsg = hb_dynsymFindName( szName );
if( pMsg )
{
PMETHOD pMethod = hb_clsFindMsg( &s_pClasses[ uiClass ], pMsg );
if( pMethod )
uiClass = pMethod->uiSprClass;
}
if( uiClass && uiClass <= s_uiClasses )
return s_pClasses[ uiClass ].szName;
}
return hb_objGetClsName( pObject );
}
| classes.c | 1335 |
STATIC LONG | hb_clsSenderOffset( void )
static LONG hb_clsSenderOffset( void )
{
LONG lOffset = hb_stackBaseProcOffset( 1 );
if( lOffset > 0 )
{
/* Is it inline method? */
if( lOffset > 0 && HB_IS_BLOCK( hb_stackItem( lOffset + 1 ) ) &&
( hb_stackItem( lOffset )->item.asSymbol.value == &hb_symEval ||
hb_stackItem( lOffset )->item.asSymbol.value->pDynSym ==
hb_symEval.pDynSym ) )
{
lOffset = hb_stackItem( lOffset )->item.asSymbol.stackstate->lBaseItem;
/* I do not like it but Class(y) makes sth like that. [druzus] */
while( lOffset > 0 &&
hb_stackItem( lOffset )->item.asSymbol.stackstate->uiClass == 0 )
lOffset = hb_stackItem( lOffset )->item.asSymbol.stackstate->lBaseItem;
}
return lOffset;
}
return -1;
}
| classes.c | 1365 |
STATIC USHORT | hb_clsSenderClasss( void )
static USHORT hb_clsSenderClasss( void )
{
LONG lOffset = hb_clsSenderOffset();
if( lOffset > 0 )
return hb_stackItem( lOffset )->item.asSymbol.stackstate->uiClass;
else
return 0;
}
| classes.c | 1391 |
STATIC USHORT | hb_clsSenderMethodClasss( void )
static USHORT hb_clsSenderMethodClasss( void )
{
LONG lOffset = hb_clsSenderOffset();
if( lOffset > 0 )
{
PHB_STACK_STATE pStack = hb_stackItem( lOffset )->item.asSymbol.stackstate;
if( pStack->uiClass )
return ( s_pClasses[ pStack->uiClass ].pMethods +
pStack->uiMethod )->uiSprClass;
}
return 0;
}
| classes.c | 1402 |
STATIC PHB_SYMB | hb_clsSenderSymbol( void )
static PHB_SYMB hb_clsSenderSymbol( void )
{
PHB_SYMB pSym = NULL;
LONG lOffset = hb_clsSenderOffset();
if( lOffset > 0 )
{
pSym = hb_stackItem( lOffset )->item.asSymbol.value;
if( pSym == &hb_symEval || pSym->pDynSym == hb_symEval.pDynSym )
{
PHB_ITEM pBlock = hb_stackItem( lOffset + 1 );
if( HB_IS_BLOCK( pBlock ) )
pSym = pBlock->item.asBlock.value->pDefSymb;
}
}
return hb_vmGetRealFuncSym( pSym );
}
| classes.c | 1417 |
STATIC USHORT | hb_clsSenderObjectClasss( void )
static USHORT hb_clsSenderObjectClasss( void )
{
LONG lOffset = hb_clsSenderOffset();
if( lOffset > 0 )
{
PHB_ITEM pSender = hb_stackItem( lOffset + 1 );
if( HB_IS_ARRAY( pSender ) )
return pSender->item.asArray.value->uiClass;
}
return 0;
}
| classes.c | 1438 |
STATIC PHB_SYMB | hb_clsValidScope( PMETHOD pMethod, PHB_STACK_STATE pStack )
static PHB_SYMB hb_clsValidScope( PMETHOD pMethod, PHB_STACK_STATE pStack )
{
if( pMethod->uiScope & ( HB_OO_CLSTP_HIDDEN | HB_OO_CLSTP_PROTECTED |
HB_OO_CLSTP_OVERLOADED ) )
{
USHORT uiSenderClass = hb_clsSenderMethodClasss();
if( uiSenderClass )
{
if( uiSenderClass == pMethod->uiSprClass )
return pMethod->pFuncSym;
/*
* Warning!!! Friends cannot access overloaded non virtual methods.
* This feature is available _ONLY_ for real class members, [druzus]
*/
if( pMethod->uiScope & HB_OO_CLSTP_OVERLOADED )
{
PCLASS pClass = &s_pClasses[ uiSenderClass ];
PMETHOD pHiddenMthd = hb_clsFindMsg( pClass, pMethod->pMessage );
if( pHiddenMthd && ( pHiddenMthd->uiScope & HB_OO_CLSTP_NONVIRTUAL ) &&
pHiddenMthd->uiSprClass == uiSenderClass )
{
pStack->uiClass = uiSenderClass;
pStack->uiMethod = ( USHORT ) ( pHiddenMthd - pClass->pMethods );
return pHiddenMthd->pFuncSym;
}
}
if( pMethod->uiScope & HB_OO_CLSTP_HIDDEN )
{
if( ! hb_clsIsFriendSymbol( &s_pClasses[ pMethod->uiSprClass ],
s_pClasses[ uiSenderClass ].pClassFuncSym ) )
return &s___msgScopeErr;
}
else if( pMethod->uiScope & HB_OO_CLSTP_PROTECTED &&
! hb_clsHasParent( &s_pClasses[ pStack->uiClass ],
s_pClasses[ uiSenderClass ].pClassSym ) &&
! hb_clsHasParent( &s_pClasses[ uiSenderClass ],
s_pClasses[ pStack->uiClass ].pClassSym ) &&
! hb_clsIsFriendSymbol( &s_pClasses[ pMethod->uiSprClass ],
s_pClasses[ uiSenderClass ].pClassFuncSym ) &&
( pStack->uiClass == pMethod->uiSprClass ||
! hb_clsIsFriendSymbol( &s_pClasses[ pStack->uiClass ],
s_pClasses[ uiSenderClass ].pClassFuncSym ) ) )
return &s___msgScopeErr;
}
else if( pMethod->uiScope & ( HB_OO_CLSTP_HIDDEN | HB_OO_CLSTP_PROTECTED ) )
{
PHB_SYMB pSym = hb_clsSenderSymbol();
if( ! hb_clsIsFriendSymbol( &s_pClasses[ pMethod->uiSprClass ], pSym ) )
{
if( ( pMethod->uiScope & HB_OO_CLSTP_HIDDEN ) ||
! hb_clsIsFriendSymbol( &s_pClasses[ pStack->uiClass ], pSym ) )
return &s___msgScopeErr;
}
}
}
return pMethod->pFuncSym;
}
| classes.c | 1452 |
STATIC PHB_SYMB | hb_clsScalarMethod( PCLASS pClass, PHB_DYNS pMsg, PHB_STACK_STATE pStack )
static PHB_SYMB hb_clsScalarMethod( PCLASS pClass, PHB_DYNS pMsg,
PHB_STACK_STATE pStack )
{
PMETHOD pMethod = hb_clsFindMsg( pClass, pMsg );
if( pStack )
{
pStack->uiClass = ( USHORT ) ( pClass - s_pClasses );
if( pMethod )
{
pStack->uiMethod = ( USHORT ) ( pMethod - pClass->pMethods );
return hb_clsValidScope( pMethod, pStack );
}
}
else if( pMethod )
return pMethod->pFuncSym;
return NULL;
}
| classes.c | 1516 |
STATIC VOID | hb_clsMakeSuperObject( PHB_ITEM pDest, PHB_ITEM pObject, USHORT uiSuperClass )
static void hb_clsMakeSuperObject( PHB_ITEM pDest, PHB_ITEM pObject,
USHORT uiSuperClass )
{
HB_TRACE(HB_TR_DEBUG, ("hb_clsMakeSuperObject(%p, %p, %hu)", pDest, pObject, uiSuperClass));
/* create a fake object array */
hb_arrayNew( pDest, 1 );
/* Now save the Self object as the 1st elem. */
hb_arraySet( pDest, 1, pObject );
/* And transform it into a fake object */
/* backup of actual handel */
pDest->item.asArray.value->uiPrevCls = hb_objGetClassH( pObject );
/* superclass handel casting */
pDest->item.asArray.value->uiClass = uiSuperClass;
}
| classes.c | 1536 |
PHB_SYMB | hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pMessage, PHB_STACK_STATE pStack )
PHB_SYMB hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pMessage,
PHB_STACK_STATE pStack )
{
PCLASS pClass = NULL;
PHB_DYNS pMsg;
HB_TRACE(HB_TR_DEBUG, ("hb_objGetMethod(%p, %p, %p)", pObject, pMessage, pStack));
pMsg = pMessage->pDynSym;
if( HB_IS_ARRAY( pObject ) )
{
if( pObject->item.asArray.value->uiClass )
{
pClass = &s_pClasses[ pObject->item.asArray.value->uiClass ];
if( pStack )
{
pStack->uiClass = pObject->item.asArray.value->uiClass;
if( pObject->item.asArray.value->uiPrevCls )
{
if( pObject->item.asArray.value->ulLen )
{
/*
* Copy real object - do not move! the same super casted
* object can be used more then once and we mustn't
* destroy it. We can safely use hb_stackReturnItem() here.
*/
hb_itemCopy( hb_stackReturnItem(), pObject->item.asArray.value->pItems );
/* move real object back to the stack */
hb_itemMove( pObject, hb_stackReturnItem() );
}
else
/* Someone tried to manipulate with supercast array */
hb_itemClear( pObject );
}
#ifdef HB_MSG_POOL
{
USHORT uiBucket = BUCKETSIZE, * puiMsgIdx =
pClass->puiMsgIdx + hb_clsBucketPos( pMsg, pClass->uiHashKey );
do
{
PMETHOD pMethod = &pClass->pMethods[ * puiMsgIdx ];
if( pMethod->pMessage == pMsg )
{
pStack->uiMethod = * puiMsgIdx;
return hb_clsValidScope( pMethod, pStack );
}
++puiMsgIdx;
}
while( --uiBucket );
}
#else
{
PMETHOD pMethod = hb_clsFindMsg( pClass, pMsg );
if( pMethod )
{
pStack->uiMethod = ( USHORT ) ( pMethod - pClass->pMethods );
return hb_clsValidScope( pMethod, pStack );
}
}
#endif
}
else
{
PMETHOD pMethod = hb_clsFindMsg( pClass, pMsg );
if( pMethod )
return pMethod->pFuncSym;
}
}
else if( s_uiArrayClass )
{
pClass = &s_pClasses[ s_uiArrayClass ];
{
PHB_SYMB pExecSym = hb_clsScalarMethod( pClass, pMsg, pStack );
if( pExecSym )
return pExecSym;
}
}
}
else if( HB_IS_BLOCK( pObject ) )
{
if( pMsg == hb_symEval.pDynSym )
return &hb_symEval;
else if( s_uiBlockClass )
{
pClass = &s_pClasses[ s_uiBlockClass ];
{
PHB_SYMB pExecSym = hb_clsScalarMethod( pClass, pMsg, pStack );
if( pExecSym )
return pExecSym;
}
}
}
else if( HB_IS_BYREF( pObject ) )
{
if( pStack )
{
/* method of enumerator variable from FOR EACH statement
*/
PHB_ITEM pEnum = hb_itemUnRefOnce( pObject );
if( HB_IS_ENUM( pEnum ) )
{
/*
* Do actions here - we already have unreferenced pEnum so
* it will be a little bit faster but in the future it's
* possible that I'll move it to separate function when
* I'll add enumerators overloading. [druzus]
*/
if( pMsg == s___msgEnumIndex.pDynSym )
{
hb_itemPutNL( hb_stackReturnItem(), pEnum->item.asEnum.offset );
if( hb_pcount() > 0 && ISNUM( 1 ) )
pEnum->item.asEnum.offset = hb_itemGetNL( hb_param( 1, HB_IT_ANY ) );
return &s___msgEnumIndex;
}
else if( pMsg == s___msgEnumKey.pDynSym )
{
PHB_ITEM pBase = HB_IS_BYREF( pEnum->item.asEnum.basePtr ) ?
hb_itemUnRef( pEnum->item.asEnum.basePtr ) :
pEnum->item.asEnum.basePtr;
if( HB_IS_HASH( pBase ) )
{
pBase = hb_hashGetKeyAt( pBase, pEnum->item.asEnum.offset );
if( pBase )
hb_itemCopy( hb_stackReturnItem(), pBase );
}
return &s___msgEnumKey;
}
else if( pMsg == s___msgEnumBase.pDynSym )
{
if( HB_IS_BYREF( pEnum->item.asEnum.basePtr ) )
hb_itemCopy( hb_stackReturnItem(),
hb_itemUnRef( pEnum->item.asEnum.basePtr ) );
else
hb_itemCopy( hb_stackReturnItem(),
pEnum->item.asEnum.basePtr );
if( hb_pcount() > 0 )
hb_itemCopy( pEnum->item.asEnum.basePtr,
hb_itemUnRef( hb_stackItemFromBase( 1 ) ) );
return &s___msgEnumBase;
}
else if( pMsg == s___msgEnumValue.pDynSym )
{
pEnum = hb_itemUnRef( pEnum );
hb_itemCopy( hb_stackReturnItem(), pEnum );
if( hb_pcount() > 0 )
hb_itemCopy( pEnum, hb_itemUnRef( hb_stackItemFromBase( 1 ) ) );
return &s___msgEnumValue;
}
}
}
}
else if( HB_IS_SYMBOL( pObject ) )
{
if( s_uiSymbolClass )
{
pClass = &s_pClasses[ s_uiSymbolClass ];
{
PHB_SYMB pExecSym = hb_clsScalarMethod( pClass, pMsg, pStack );
if( pExecSym )
return pExecSym;
}
}
if( pMsg == s___msgExec.pDynSym || pMsg == hb_symEval.pDynSym )
{
if( ! pObject->item.asSymbol.value->value.pFunPtr &&
pObject->item.asSymbol.value->pDynSym )
return pObject->item.asSymbol.value->pDynSym->pSymbol;
else
return pObject->item.asSymbol.value;
}
else if( pMsg == s___msgName.pDynSym )
{
hb_itemPutC( hb_stackReturnItem(),
pObject->item.asSymbol.value->szName );
return &s___msgName;
}
}
else if( HB_IS_HASH( pObject ) )
{
if( s_uiHashClass )
{
pClass = &s_pClasses[ s_uiHashClass ];
{
PHB_SYMB pExecSym = hb_clsScalarMethod( pClass, pMsg, pStack );
if( pExecSym )
return pExecSym;
}
}
if( pMsg == s___msgKeys.pDynSym )
{
hb_itemReturnRelease( hb_hashGetKeys( pObject ) );
return &s___msgKeys;
}
else if( pMsg == s___msgValues.pDynSym )
{
hb_itemReturnRelease( hb_hashGetValues( pObject ) );
return &s___msgValues;
}
#if defined( HB_HASH_MSG_ITEMS )
else
{
if( hb_pcount() == 1 && pMessage->szName[ 0 ] == '_' )
{ /* ASSIGN */
PHB_ITEM pIndex = hb_itemPutCConst( hb_stackAllocItem(), pMessage->szName + 1 );
PHB_ITEM pDest = hb_hashGetItemPtr( pObject, pIndex, HB_HASH_AUTOADD_ASSIGN );
hb_stackPop();
if( pDest )
{
PHB_ITEM pValue = hb_param( 1, HB_IT_ANY );
hb_itemCopyFromRef( pDest, pValue );
hb_itemReturn( pValue );
return &s___msgVirtual;
}
}
else if( hb_pcount() == 0 )
{ /* ACCESS */
PHB_ITEM pIndex = hb_itemPutCConst( hb_stackAllocItem(), pMessage->szName );
PHB_ITEM pValue = hb_hashGetItemPtr( pObject, pIndex, HB_HASH_AUTOADD_ACCESS );
hb_stackPop();
if( pValue )
{
hb_itemReturn( pValue );
return &s___msgVirtual;
}
}
}
#endif
}
else if( HB_IS_STRING( pObject ) )
{
if( s_uiCharacterClass )
{
pClass = &s_pClasses[ s_uiCharacterClass ];
{
PHB_SYMB pExecSym = hb_clsScalarMethod( pClass, pMsg, pStack );
if( pExecSym )
return pExecSym;
}
}
}
else if( HB_IS_DATE( pObject ) )
{
if( s_uiDateClass )
{
pClass = &s_pClasses[ s_uiDateClass ];
{
PHB_SYMB pExecSym = hb_clsScalarMethod( pClass, pMsg, pStack );
if( pExecSym )
return pExecSym;
}
}
}
else if( HB_IS_NUMERIC( pObject ) )
{
if( s_uiNumericClass )
{
pClass = &s_pClasses[ s_uiNumericClass ];
{
PHB_SYMB pExecSym = hb_clsScalarMethod( pClass, pMsg, pStack );
if( pExecSym )
return pExecSym;
}
}
}
else if( HB_IS_LOGICAL( pObject ) )
{
if( s_uiLogicalClass )
{
pClass = &s_pClasses[ s_uiLogicalClass ];
{
PHB_SYMB pExecSym = hb_clsScalarMethod( pClass, pMsg, pStack );
if( pExecSym )
return pExecSym;
}
}
}
else if( HB_IS_POINTER( pObject ) )
{
if( s_uiPointerClass )
{
pClass = &s_pClasses[ s_uiPointerClass ];
{
PHB_SYMB pExecSym = hb_clsScalarMethod( pClass, pMsg, pStack );
if( pExecSym )
return pExecSym;
}
}
}
else if( HB_IS_NIL( pObject ) )
{
if( s_uiNilClass )
{
pClass = &s_pClasses[ s_uiNilClass ];
{
PHB_SYMB pExecSym = hb_clsScalarMethod( pClass, pMsg, pStack );
if( pExecSym )
return pExecSym;
}
}
}
/* Default messages here */
if( pMsg == s___msgWithObjectPush.pDynSym )
{
if( pStack )
{
PHB_ITEM pItem = hb_stackWithObjectItem();
if( pItem )
{
/* push current WITH OBJECT object */
hb_itemCopy( hb_stackReturnItem(), pItem );
return &s___msgWithObjectPush;
}
}
}
else if( pMsg == s___msgWithObjectPop.pDynSym )
{
if( pStack )
{
PHB_ITEM pItem = hb_stackWithObjectItem();
if( pItem )
{
/* replace current WITH OBJECT object */
hb_itemCopy( pItem, hb_stackItemFromBase( 1 ) );
hb_itemCopy( hb_stackReturnItem(), pItem );
return &s___msgWithObjectPop;
}
}
}
else if( pMsg == s___msgClassName.pDynSym )
return &s___msgClassName;
else if( pMsg == s___msgClassH.pDynSym )
return &s___msgClassH;
else if( pMsg == s___msgClassSel.pDynSym )
return &s___msgClassSel;
/*
else if( pMsg == s___msgClsParent.pDynSym )
return &s___msgClsParent;
else if( pMsg == s___msgClass.pDynSym )
return &s___msgClass;
*/
if( pStack )
{
if( pClass && pClass->fHasOnError )
{
PMETHOD pMethod = hb_clsFindMsg( pClass, s___msgOnError.pDynSym );
if( pMethod )
{
pStack->uiMethod = ( USHORT ) ( pMethod - pClass->pMethods );
return pMethod->pFuncSym;
}
}
/* remove this line if you want default HVM error message */
return &s___msgNoMethod;
}
return NULL;
}
| classes.c | 1552 |
BOOL | hb_objGetVarRef( PHB_ITEM pObject, PHB_SYMB pMessage, PHB_STACK_STATE pStack )
BOOL hb_objGetVarRef( PHB_ITEM pObject, PHB_SYMB pMessage,
PHB_STACK_STATE pStack )
{
PHB_SYMB pExecSym;
#if defined( HB_HASH_MSG_ITEMS )
if( HB_IS_HASH( pObject ) )
{
PHB_ITEM pIndex = hb_itemPutCConst( hb_stackAllocItem(), pMessage->szName + 1 );
PHB_ITEM pValue = hb_hashGetItemRefPtr( pObject, pIndex );
hb_stackPop();
if( pValue )
hb_itemReturn( pValue );
return pValue != NULL;
}
#endif
pExecSym = hb_objGetMethod( pObject, pMessage, pStack );
if( pExecSym )
{
if( pExecSym->value.pFunPtr == hb___msgSetData )
{
USHORT uiObjClass = pObject->item.asArray.value->uiClass;
PCLASS pClass = &s_pClasses[ pStack->uiClass ];
PMETHOD pMethod = pClass->pMethods + pStack->uiMethod;
ULONG ulIndex = pMethod->uiData;
if( pStack->uiClass != uiObjClass )
ulIndex += hb_clsParentInstanceOffset( &s_pClasses[ uiObjClass ],
s_pClasses[ pMethod->uiSprClass ].pClassSym );
else
ulIndex += pMethod->uiOffset;
/* will arise only if the class has been modified after first instance */
if( ulIndex > hb_arrayLen( pObject ) ) /* Resize needed */
hb_arraySize( pObject, ulIndex ); /* Make large enough */
return hb_arrayGetItemRef( pObject, ulIndex, hb_stackReturnItem() );
}
else if( pExecSym->value.pFunPtr == hb___msgSetClsData )
{
PCLASS pClass = &s_pClasses[ pStack->uiClass ];
PMETHOD pMethod = pClass->pMethods + pStack->uiMethod;
return hb_arrayGetItemRef( pClass->pClassDatas, pMethod->uiData,
hb_stackReturnItem() );
}
else if( pExecSym->value.pFunPtr == hb___msgSetShrData )
{
PCLASS pClass = &s_pClasses[ pStack->uiClass ];
PMETHOD pMethod = pClass->pMethods + pStack->uiMethod;
return hb_arrayGetItemRef( s_pClasses[ pMethod->uiSprClass ].pSharedDatas,
pMethod->uiData, hb_stackReturnItem() );
}
else if( pExecSym->value.pFunPtr == hb___msgScopeErr )
{
pExecSym->value.pFunPtr();
}
else
{
PCLASS pClass = &s_pClasses[ pStack->uiClass ];
PMETHOD pMethod = pClass->pMethods + pStack->uiMethod;
if( !pMethod->pAccMsg )
pMethod->pAccMsg = hb_dynsymGetCase( pMessage->szName + 1 );
return hb_vmMsgReference( pObject, pMessage->pDynSym, pMethod->pAccMsg );
}
}
return FALSE;
}
| classes.c | 1925 |
BOOL | hb_clsHasDestructor( USHORT uiClass )
BOOL hb_clsHasDestructor( USHORT uiClass )
{
if( uiClass && uiClass <= s_uiClasses )
return s_pClasses[ uiClass ].fHasDestructor;
else
return FALSE;
}
| classes.c | 1999 |
STATIC VOID | hb_objSupperDestructorCall( PHB_ITEM pObject, PCLASS pClass )
static void hb_objSupperDestructorCall( PHB_ITEM pObject, PCLASS pClass )
{
PMETHOD pMethod = pClass->pMethods;
ULONG ulLimit = hb_clsMthNum( pClass );
BYTE * pbClasses;
USHORT uiClass;
pbClasses = ( BYTE * ) hb_xgrab( s_uiClasses + 1 );
memset( pbClasses, 0, s_uiClasses + 1 );
do
{
if( pMethod->pMessage )
{
if( pMethod->pFuncSym == &s___msgSuper )
{
PCLASS pSupperClass = &s_pClasses[ pMethod->uiSprClass ];
if( pSupperClass->fHasDestructor && pSupperClass != pClass )
pbClasses[ pMethod->uiSprClass ] |= 1;
}
else if( pMethod->pMessage == s___msgDestructor.pDynSym )
pbClasses[ pMethod->uiSprClass ] |= 2;
}
++pMethod;
}
while( --ulLimit );
for( uiClass = s_uiClasses; uiClass; --uiClass )
{
if( pbClasses[ uiClass ] == 1 )
{
PMETHOD pDestructor = hb_clsFindMsg( &s_pClasses[ uiClass ],
s___msgDestructor.pDynSym );
if( pDestructor )
{
if( pbClasses[ pDestructor->uiSprClass ] == 1 )
{
hb_vmPushSymbol( &s___msgDestructor );
hb_clsMakeSuperObject( hb_stackAllocItem(), pObject, uiClass );
hb_vmSend( 0 );
if( hb_vmRequestQuery() != 0 )
break;
pbClasses[ pDestructor->uiSprClass ] |= 2;
}
}
}
}
hb_xfree( pbClasses );
}
| classes.c | 2010 |
VOID | hb_objDestructorCall( PHB_ITEM pObject )
void hb_objDestructorCall( PHB_ITEM pObject )
{
if( HB_IS_OBJECT( pObject ) &&
pObject->item.asArray.value->uiClass <= s_uiClasses )
{
PCLASS pClass = &s_pClasses[ pObject->item.asArray.value->uiClass ];
if( pClass->fHasDestructor )
{
if( hb_vmRequestReenter() )
{
hb_vmPushSymbol( &s___msgDestructor );
hb_vmPush( pObject );
hb_vmSend( 0 );
if( hb_vmRequestQuery() == 0 )
hb_objSupperDestructorCall( pObject, pClass );
hb_vmRequestRestore();
}
}
}
}
| classes.c | 2064 |
BOOL | hb_objHasOperator( PHB_ITEM pObject, USHORT uiOperator )
BOOL hb_objHasOperator( PHB_ITEM pObject, USHORT uiOperator )
{
USHORT uiClass;
HB_TRACE(HB_TR_DEBUG, ("hb_objHasOperator(%p,%hu)", pObject, uiOperator));
uiClass = hb_objGetClassH( pObject );
if( uiClass && uiClass <= s_uiClasses )
{
return ( s_pClasses[ uiClass ].ulOpFlags & ( 1UL << uiOperator ) ) != 0;
}
return FALSE;
}
| classes.c | 2089 |
BOOL | hb_objOperatorCall( USHORT uiOperator, HB_ITEM_PTR pResult, PHB_ITEM pObject, PHB_ITEM pMsgArg1, PHB_ITEM pMsgArg2 )
BOOL hb_objOperatorCall( USHORT uiOperator, HB_ITEM_PTR pResult, PHB_ITEM pObject,
PHB_ITEM pMsgArg1, PHB_ITEM pMsgArg2 )
{
HB_TRACE(HB_TR_DEBUG, ("hb_objOperatorCall(%hu,%p,%p,%p,%p)", uiOperator, pResult, pObject, pMsgArg1, pMsgArg2));
if( hb_objHasOperator( pObject, uiOperator ) )
{
hb_vmPushSymbol( s_opSymbols + uiOperator );
hb_vmPush( pObject );
hb_itemSetNil( hb_stackReturnItem() );
if( pMsgArg1 )
{
hb_vmPush( pMsgArg1 );
if( pMsgArg2 )
{
hb_vmPush( pMsgArg2 );
hb_vmSend( 2 );
}
else
hb_vmSend( 1 );
}
else
hb_vmSend( 0 );
/* store the return value */
hb_itemMove( pResult, hb_stackReturnItem() );
return TRUE;
}
return FALSE;
}
| classes.c | 2107 |
HB_EXPORT BOOL | hb_objHasMessage( PHB_ITEM pObject, PHB_DYNS pMessage )
HB_EXPORT BOOL hb_objHasMessage( PHB_ITEM pObject, PHB_DYNS pMessage )
{
return hb_objGetMethod( pObject, pMessage->pSymbol, NULL ) != NULL;
}
| classes.c | 2143 |
HB_EXPORT BOOL | hb_objHasMsg( PHB_ITEM pObject, const char *szString )
HB_EXPORT BOOL hb_objHasMsg( PHB_ITEM pObject, const char *szString )
{
PHB_DYNS pDynSym;
HB_TRACE(HB_TR_DEBUG, ("hb_objHasMsg(%p, %s)", pObject, szString));
pDynSym = hb_dynsymFindName( szString );
if( pDynSym )
{
return hb_objGetMethod( pObject, pDynSym->pSymbol, NULL ) != NULL;
}
else
{
return FALSE;
}
}
| classes.c | 2151 |
HB_EXPORT PHB_ITEM | hb_objSendMessage( PHB_ITEM pObject, PHB_DYNS pMsgSym, ULONG ulArg, ... )
HB_EXPORT PHB_ITEM hb_objSendMessage( PHB_ITEM pObject, PHB_DYNS pMsgSym, ULONG ulArg, ... )
{
if( pObject && pMsgSym )
{
hb_vmPushSymbol( pMsgSym->pSymbol );
hb_vmPush( pObject );
if( ulArg )
{
unsigned long i;
va_list ap;
va_start( ap, ulArg );
for( i = 0; i < ulArg; i++ )
{
hb_vmPush( va_arg( ap, PHB_ITEM ) );
}
va_end( ap );
}
hb_vmSend( (USHORT) ulArg );
}
else
hb_errRT_BASE( EG_ARG, 3000, NULL, "__ObjSendMessage()", 0 );
return hb_stackReturnItem();
}
| classes.c | 2175 |
HB_EXPORT PHB_ITEM | hb_objSendMsg( PHB_ITEM pObject, const char *sMsg, ULONG ulArg, ... )
HB_EXPORT PHB_ITEM hb_objSendMsg( PHB_ITEM pObject, const char *sMsg, ULONG ulArg, ... )
{
hb_vmPushSymbol( hb_dynsymGet( sMsg )->pSymbol );
hb_vmPush( pObject );
if( ulArg )
{
unsigned long i;
va_list ap;
va_start( ap, ulArg );
for( i = 0; i < ulArg; i++ )
{
hb_vmPush( va_arg( ap, PHB_ITEM ) );
}
va_end( ap );
}
hb_vmSend( (USHORT) ulArg );
return hb_stackReturnItem();
}
| classes.c | 2202 |
STATIC PHB_DYNS | hb_objGetMsgSym( PHB_ITEM pMessage )
static PHB_DYNS hb_objGetMsgSym( PHB_ITEM pMessage )
{
PHB_DYNS pDynSym = NULL;
if( pMessage )
{
const char * szMsg = NULL;
if( HB_IS_STRING( pMessage ) )
szMsg = pMessage->item.asString.value;
else if( HB_IS_SYMBOL( pMessage ) )
{
pDynSym = pMessage->item.asSymbol.value->pDynSym;
if( !pDynSym )
szMsg = pMessage->item.asSymbol.value->szName;
}
if( szMsg && *szMsg )
pDynSym = hb_dynsymGet( szMsg );
}
return pDynSym;
}
| classes.c | 2223 |
STATIC PHB_SYMB | hb_objGetFuncSym( PHB_ITEM pItem )
static PHB_SYMB hb_objGetFuncSym( PHB_ITEM pItem )
{
if( pItem )
{
if( HB_IS_SYMBOL( pItem ) )
return pItem->item.asSymbol.value;
else if( HB_IS_STRING( pItem ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( hb_itemGetCPtr( pItem ) );
if( pDynSym && pDynSym->pSymbol->value.pFunPtr )
return pDynSym->pSymbol;
}
}
return NULL;
}
| classes.c | 2247 |
HB_EXPORT VOID | hb_dbgObjSendMessage( int iProcLevel, PHB_ITEM pObject, PHB_ITEM pMessage, int iParamOffset )
HB_EXPORT void hb_dbgObjSendMessage( int iProcLevel, PHB_ITEM pObject, PHB_ITEM pMessage, int iParamOffset )
{
PHB_DYNS pMsgSym;
pMsgSym = hb_objGetMsgSym( pMessage );
if( pObject && pMsgSym )
{
USHORT uiParams = 0;
/* set requested sender class and method id for scope verification */
if( iProcLevel > 0 )
{
int iLevel = hb_stackCallDepth();
if( iProcLevel < iLevel )
{
LONG lOffset = hb_stackBaseProcOffset( iLevel - iProcLevel );
if( lOffset > 0 )
{
PHB_ITEM pItem = hb_stackItem( lOffset );
PHB_ITEM pBase = hb_stackBaseItem();
pBase->item.asSymbol.stackstate->uiClass =
pItem->item.asSymbol.stackstate->uiClass;
pBase->item.asSymbol.stackstate->uiMethod =
pItem->item.asSymbol.stackstate->uiMethod;
}
}
}
else if( iProcLevel == 0 )
{
/* set scope like for internal object messages to any visible
method without respecting overloaded methods */
USHORT uiClass = hb_objGetClassH( pObject );
if( uiClass && uiClass <= s_uiClasses )
{
PMETHOD pMethod = hb_clsFindMsg( &s_pClasses[ uiClass ], pMsgSym );
if( pMethod )
{
PHB_ITEM pBase = hb_stackBaseItem();
pBase->item.asSymbol.stackstate->uiClass = uiClass;
pBase->item.asSymbol.stackstate->uiMethod =
( USHORT ) ( pMethod - s_pClasses[ uiClass ].pMethods );
}
}
}
hb_vmPushSymbol( pMsgSym->pSymbol );
hb_vmPush( pObject );
if( iParamOffset > 0 )
{
int iPCount = hb_pcount();
while( iParamOffset <= iPCount )
{
hb_vmPush( hb_stackItemFromBase( iParamOffset ) );
++uiParams;
++iParamOffset;
}
}
hb_vmSend( uiParams );
}
else
hb_errRT_BASE( EG_ARG, 3000, NULL, "hb_dbgObjSendMessage()", 2, pObject, pMsgSym );
}
| classes.c | 2265 |
STATIC USHORT | hb_clsUpdateScope( USHORT uiScope, BOOL fAssign )
static USHORT hb_clsUpdateScope( USHORT uiScope, BOOL fAssign )
{
if( !fAssign )
uiScope &= ~HB_OO_CLSTP_READONLY;
else
{
uiScope &= ~HB_OO_CLSTP_PERSIST;
if( ( uiScope & HB_OO_CLSTP_READONLY ) &&
!( uiScope & HB_OO_CLSTP_HIDDEN ) )
{
/* Class(y) does not allow to write to HIDDEN+READONLY
instance variables, [druzus] */
uiScope &= ~HB_OO_CLSTP_READONLY;
uiScope |= uiScope & HB_OO_CLSTP_PROTECTED ?
HB_OO_CLSTP_HIDDEN : HB_OO_CLSTP_PROTECTED;
}
}
return uiScope;
}
| classes.c | 2333 |
STATIC HB_TYPE | hb_clsGetItemType( PHB_ITEM pItem, HB_TYPE nDefault )
static HB_TYPE hb_clsGetItemType( PHB_ITEM pItem, HB_TYPE nDefault )
{
if( pItem )
{
if( HB_IS_STRING( pItem ) )
{
switch( hb_itemGetCPtr( pItem )[ 0 ] )
{
case 'C':
case 'c':
case '\0':
if( hb_strnicmp( hb_itemGetCPtr( pItem ), "code", 4 ) == 0 )
return HB_IT_BLOCK;
else
return HB_IT_STRING;
case 'S':
case 's':
if( hb_strnicmp( hb_itemGetCPtr( pItem ), "str", 3 ) == 0 )
return HB_IT_STRING;
else
return HB_IT_SYMBOL;
case 'B':
case 'b':
return HB_IT_BLOCK;
case 'D':
case 'd':
return HB_IT_DATE;
case 'L':
case 'l':
return HB_IT_LOGICAL;
case 'I':
case 'i':
return HB_IT_NUMINT;
case 'N':
case 'n':
if( hb_stricmp( hb_itemGetCPtr( pItem ), "nil" ) == 0 )
return HB_IT_NIL;
else
return HB_IT_NUMERIC;
case 'A':
case 'a':
return HB_IT_ARRAY;
case 'P':
case 'p':
return HB_IT_POINTER;
case 'H':
case 'h':
return HB_IT_HASH;
}
}
else if( HB_IS_ARRAY( pItem ) )
{
if( pItem->item.asArray.value->uiClass == 0 )
return HB_IT_ARRAY;
}
else if( HB_IS_NUMINT( pItem ) )
return HB_IT_NUMINT;
else if( HB_IS_NUMERIC( pItem ) )
return HB_IT_NUMERIC;
else if( HB_IS_DATE( pItem ) )
return HB_IT_DATE;
else if( HB_IS_LOGICAL( pItem ) )
return HB_IT_LOGICAL;
else if( HB_IS_BLOCK( pItem ) )
return HB_IT_BLOCK;
else if( HB_IS_POINTER( pItem ) )
return HB_IT_POINTER;
else if( HB_IS_SYMBOL( pItem ) )
return HB_IT_SYMBOL;
else if( HB_IS_NIL( pItem ) )
return HB_IT_NIL;
}
return nDefault;
}
| classes.c | 2355 |
STATIC BOOL | hb_clsAddMsg( USHORT uiClass, const char * szMessage, USHORT uiType, USHORT uiScope, PHB_ITEM pFunction, PHB_ITEM pInit )
static BOOL hb_clsAddMsg( USHORT uiClass, const char * szMessage,
USHORT uiType, USHORT uiScope,
PHB_ITEM pFunction, PHB_ITEM pInit )
{
if( szMessage && uiClass && uiClass <= s_uiClasses )
{
PCLASS pClass = &s_pClasses[ uiClass ];
PHB_DYNS pMessage;
PMETHOD pNewMeth;
USHORT uiOperator, uiSprClass = 0, uiIndex = 0, uiPrevCls, uiPrevMth;
PHB_SYMB pOpSym, pFuncSym = NULL;
BOOL fOK;
ULONG ulOpFlags = 0;
if( pClass->fLocked )
return FALSE;
if( !( uiScope & ( HB_OO_CLSTP_EXPORTED | HB_OO_CLSTP_PROTECTED | HB_OO_CLSTP_HIDDEN ) ) )
uiScope |= HB_OO_CLSTP_EXPORTED;
/* translate names of operator overloading messages */
if( uiType == HB_OO_MSG_DESTRUCTOR )
pMessage = s___msgDestructor.pDynSym;
else if( uiType == HB_OO_MSG_ONERROR )
pMessage = s___msgOnError.pDynSym;
else if( strcmp( "+", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_PLUS )->pDynSym;
else if( strcmp( "-", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_MINUS )->pDynSym;
else if( strcmp( "*", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_MULT )->pDynSym;
else if( strcmp( "/", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_DIVIDE )->pDynSym;
else if( strcmp( "%", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_MOD )->pDynSym;
else if( strcmp( "^", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_POWER )->pDynSym;
else if( strcmp( "**", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_POWER )->pDynSym;
else if( strcmp( "++", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_INC )->pDynSym;
else if( strcmp( "--", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_DEC )->pDynSym;
else if( strcmp( "==", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_EXACTEQUAL )->pDynSym;
else if( strcmp( "=", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_EQUAL )->pDynSym;
else if( strcmp( "!=", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_NOTEQUAL )->pDynSym;
else if( strcmp( "<>", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_NOTEQUAL )->pDynSym;
else if( strcmp( "#", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_NOTEQUAL )->pDynSym;
else if( strcmp( "<", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_LESS )->pDynSym;
else if( strcmp( "<=", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_LESSEQUAL )->pDynSym;
else if( strcmp( ">", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_GREATER )->pDynSym;
else if( strcmp( ">=", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_GREATEREQUAL )->pDynSym;
else if( strcmp( ":=", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_ASSIGN )->pDynSym;
else if( strcmp( "$", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_INSTRING )->pDynSym;
else if( strcmp( "$$", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_INCLUDE )->pDynSym;
else if( strcmp( "!", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_NOT )->pDynSym;
else if( hb_stricmp( ".NOT.", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_NOT )->pDynSym;
else if( hb_stricmp( ".AND.", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_AND )->pDynSym;
else if( hb_stricmp( ".OR.", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_OR )->pDynSym;
else if( strcmp( "[]", szMessage ) == 0 )
pMessage = ( s_opSymbols + HB_OO_OP_ARRAYINDEX )->pDynSym;
else
pMessage = hb_dynsymGet( szMessage );
for( uiOperator = 0, pOpSym = s_opSymbols;
uiOperator <= HB_OO_MAX_OPERATOR; ++uiOperator, ++pOpSym )
{
if( pOpSym->pDynSym == pMessage )
{
ulOpFlags |= 1UL << uiOperator;
break;
}
}
/* basic parameter validation */
switch( uiType )
{
case HB_OO_MSG_METHOD:
case HB_OO_MSG_ONERROR:
case HB_OO_MSG_DESTRUCTOR:
pFuncSym = hb_objGetFuncSym( pFunction );
fOK = pFuncSym != NULL;
break;
case HB_OO_MSG_INLINE:
fOK = pFunction && HB_IS_BLOCK( pFunction );
break;
case HB_OO_MSG_SUPER:
uiIndex = ( USHORT ) hb_itemGetNI( pFunction );
uiSprClass = ( USHORT ) hb_itemGetNI( pInit );
fOK = uiSprClass && uiSprClass <= s_uiClasses &&
uiIndex <= pClass->uiDatas;
break;
case HB_OO_MSG_ASSIGN:
case HB_OO_MSG_ACCESS:
uiIndex = ( USHORT ) hb_itemGetNI( pFunction );
/* This validation can break buggy .prg code which wrongly
* sets data offsets but IMHO it will help to clean the code.
* [druzus]
*/
fOK = uiIndex && uiIndex <= pClass->uiDatas - pClass->uiDataFirst;
break;
case HB_OO_MSG_CLSASSIGN:
case HB_OO_MSG_CLSACCESS:
uiIndex = ( USHORT ) hb_itemGetNI( pFunction );
fOK = uiIndex != 0;
break;
case HB_OO_MSG_DELEGATE:
{
PHB_DYNS pDelegMsg = hb_objGetMsgSym( pFunction );
if( pDelegMsg )
{
pNewMeth = hb_clsFindMsg( pClass, pDelegMsg );
if( pNewMeth )
uiIndex = ( USHORT ) ( pNewMeth - pClass->pMethods );
}
fOK = uiIndex != 0;
break;
}
case HB_OO_MSG_REALCLASS:
case HB_OO_MSG_VIRTUAL:
case HB_OO_MSG_PERFORM:
fOK = TRUE;
break;
default:
fOK = FALSE;
}
if( !fOK )
{
hb_errRT_BASE( EG_ARG, 3000, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return FALSE;
}
pNewMeth = hb_clsAllocMsg( pClass, pMessage );
if( ! pNewMeth )
return FALSE;
uiPrevCls = uiClass;
uiPrevMth = ( USHORT ) ( pClass->pMethods - pNewMeth );
#ifndef HB_VIRTUAL_HIDDEN
if( uiScope & HB_OO_CLSTP_HIDDEN )
uiScope |= HB_OO_CLSTP_NONVIRTUAL;
#endif
if( ! pNewMeth->pMessage )
pClass->uiMethods++; /* One more message */
else
{
BOOL fOverLoad = ( pNewMeth->uiScope & HB_OO_CLSTP_OVERLOADED ) ||
( ( pNewMeth->uiScope & HB_OO_CLSTP_NONVIRTUAL ) &&
pNewMeth->uiSprClass != uiClass );
uiPrevCls = pNewMeth->uiPrevCls;
uiPrevMth = pNewMeth->uiPrevMth;
if( ! hb_clsCanClearMethod( pNewMeth, TRUE ) )
return FALSE;
memset( pNewMeth, 0, sizeof( METHOD ) );
if( fOverLoad )
uiScope |= HB_OO_CLSTP_OVERLOADED;
}
pNewMeth->pMessage = pMessage;
pNewMeth->uiSprClass = uiClass;
pNewMeth->uiPrevCls = uiPrevCls;
pNewMeth->uiPrevMth = uiPrevMth;
switch( uiType )
{
case HB_OO_MSG_METHOD:
pNewMeth->pFuncSym = pFuncSym;
pNewMeth->uiScope = uiScope;
break;
case HB_OO_MSG_ASSIGN:
pNewMeth->uiScope = hb_clsUpdateScope( uiScope, TRUE );
/* Class(y) does not allow to write to HIDDEN+READONLY
instance variables, [druzus] */
if( pNewMeth->uiScope & HB_OO_CLSTP_READONLY &&
pNewMeth->uiScope & HB_OO_CLSTP_HIDDEN )
pNewMeth->pFuncSym = &s___msgScopeErr;
else
{
pNewMeth->pFuncSym = &s___msgSetData;
pNewMeth->uiData = uiIndex;
pNewMeth->uiOffset = pClass->uiDataFirst;
pNewMeth->itemType = hb_clsGetItemType( pInit, 0 );
}
break;
case HB_OO_MSG_ACCESS:
pNewMeth->uiScope = hb_clsUpdateScope( uiScope, FALSE );
pNewMeth->uiData = uiIndex;
pNewMeth->uiOffset = pClass->uiDataFirst;
hb_clsAddInitValue( pClass, pInit, HB_OO_MSG_DATA,
pNewMeth->uiData, pNewMeth->uiOffset, uiClass );
pNewMeth->pFuncSym = &s___msgGetData;
break;
case HB_OO_MSG_CLSASSIGN:
pNewMeth->uiData = uiIndex;
pNewMeth->itemType = hb_clsGetItemType( pInit, 0 );
pNewMeth->uiScope = hb_clsUpdateScope( uiScope, TRUE );
/* Class(y) does not allow to write to HIDDEN+READONLY
instance variables, [druzus] */
if( pNewMeth->uiScope & HB_OO_CLSTP_READONLY &&
pNewMeth->uiScope & HB_OO_CLSTP_HIDDEN )
pNewMeth->pFuncSym = &s___msgScopeErr;
else if( pNewMeth->uiScope & HB_OO_CLSTP_SHARED )
{
if( hb_arrayLen( pClass->pSharedDatas ) < ( ULONG ) pNewMeth->uiData )
hb_arraySize( pClass->pSharedDatas, pNewMeth->uiData );
pNewMeth->pFuncSym = &s___msgSetShrData;
}
else
{
if( hb_arrayLen( pClass->pClassDatas ) < ( ULONG ) pNewMeth->uiData )
hb_arraySize( pClass->pClassDatas, pNewMeth->uiData );
pNewMeth->pFuncSym = &s___msgSetClsData;
}
break;
case HB_OO_MSG_CLSACCESS:
pNewMeth->uiScope = hb_clsUpdateScope( uiScope, FALSE );
pNewMeth->uiData = uiIndex;
if( pNewMeth->uiScope & HB_OO_CLSTP_SHARED )
{
if( hb_arrayLen( pClass->pSharedDatas ) < ( ULONG ) pNewMeth->uiData )
hb_arraySize( pClass->pSharedDatas, pNewMeth->uiData );
if( pInit && ! HB_IS_NIL( pInit ) ) /* Initializer found */
{
/* Shared Classdata need to be initialized only once
* ACCESS/ASSIGN methods will be inherited by subclasses
* and will operate on this value so it's not necessary
* to keep the init value. [druzus]
*/
pInit = hb_itemClone( pInit );
hb_arraySet( pClass->pSharedDatas, pNewMeth->uiData, pInit );
hb_itemRelease( pInit );
}
pNewMeth->pFuncSym = &s___msgGetShrData;
}
else
{
if( hb_arrayLen( pClass->pClassDatas ) < ( ULONG ) pNewMeth->uiData )
hb_arraySize( pClass->pClassDatas, pNewMeth->uiData );
pNewMeth->uiOffset = hb_clsAddInitValue( pClass, pInit,
HB_OO_MSG_CLASSDATA, pNewMeth->uiData, 0, uiClass );
pNewMeth->pFuncSym = &s___msgGetClsData;
}
break;
case HB_OO_MSG_INLINE:
pNewMeth->pFuncSym = &s___msgEvalInline;
pNewMeth->uiScope = uiScope;
hb_arrayAdd( pClass->pInlines, pFunction );
pNewMeth->uiData = ( USHORT ) hb_arrayLen( pClass->pInlines );
break;
case HB_OO_MSG_VIRTUAL:
pNewMeth->pFuncSym = &s___msgVirtual;
pNewMeth->uiScope = uiScope;
break;
case HB_OO_MSG_SUPER:
pNewMeth->uiSprClass = uiSprClass; /* store the super handel */
pNewMeth->uiOffset = uiIndex; /* offset to instance area */
pNewMeth->uiScope = uiScope;
pNewMeth->pFuncSym = &s___msgSuper;
break;
case HB_OO_MSG_REALCLASS:
pNewMeth->pFuncSym = &s___msgRealClass;
pNewMeth->uiScope = uiScope;
break;
case HB_OO_MSG_PERFORM:
pNewMeth->pFuncSym = &s___msgPerform;
pNewMeth->uiScope = uiScope;
break;
case HB_OO_MSG_DELEGATE:
pNewMeth->pFuncSym = &s___msgDelegate;
pNewMeth->uiScope = uiScope;
pNewMeth->uiData = uiIndex;
break;
case HB_OO_MSG_ONERROR:
pNewMeth->pFuncSym = pFuncSym;
pClass->fHasOnError = TRUE;
break;
case HB_OO_MSG_DESTRUCTOR:
pNewMeth->pFuncSym = pFuncSym;
pClass->fHasDestructor = TRUE;
break;
default:
hb_errInternal( HB_EI_CLSINVMETHOD, NULL, "__clsAddMsg()", NULL );
return FALSE;
}
pClass->ulOpFlags |= ulOpFlags;
}
return TRUE;
}
| classes.c | 2449 |
HB_FUNC | __CLSADDMSG(void)
HB_FUNC( __CLSADDMSG )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
char * szMessage = hb_parc( 2 );
if( szMessage && uiClass && uiClass <= s_uiClasses )
{
USHORT nType = ( USHORT ) hb_parni( 4 );
USHORT uiScope = ( USHORT ) hb_parni( 6 );
PHB_ITEM pFunction = hb_param( 3, HB_IT_ANY );
PHB_ITEM pInit = hb_param( 5, HB_IT_ANY );
if( nType == HB_OO_MSG_DATA )
{
nType = szMessage[ 0 ] == '_' ? HB_OO_MSG_ASSIGN : HB_OO_MSG_ACCESS;
}
else if( nType == HB_OO_MSG_CLASSDATA )
{
nType = szMessage[ 0 ] == '_' ? HB_OO_MSG_CLSASSIGN :
HB_OO_MSG_CLSACCESS;
}
/* to make xHarbour users happy ;-) */
else if( nType == HB_OO_MSG_PROPERTY ||
nType == HB_OO_MSG_CLASSPROPERTY )
{
char szAssign[ HB_SYMBOL_NAME_LEN + 1 ];
int iLen = ( int ) hb_parclen( 2 );
if( iLen >= HB_SYMBOL_NAME_LEN )
iLen = HB_SYMBOL_NAME_LEN - 1;
szAssign[ 0 ] = '_';
memcpy( szAssign + 1, szMessage, iLen );
szAssign[ iLen + 1 ] = '\0';
uiScope = ( uiScope | HB_OO_CLSTP_EXPORTED ) &
~( HB_OO_CLSTP_PROTECTED | HB_OO_CLSTP_HIDDEN );
if( nType == HB_OO_MSG_PROPERTY )
{
hb_clsAddMsg( uiClass, szAssign, HB_OO_MSG_ASSIGN,
uiScope & ~HB_OO_CLSTP_PERSIST, pFunction, pInit );
nType = HB_OO_MSG_ACCESS;
}
else
{
hb_clsAddMsg( uiClass, szAssign, HB_OO_MSG_CLSASSIGN,
uiScope & ~HB_OO_CLSTP_PERSIST, pFunction, pInit );
nType = HB_OO_MSG_CLSACCESS;
}
}
hb_clsAddMsg( uiClass, szMessage, nType, uiScope, pFunction, pInit );
}
}
| classes.c | 2890 |
STATIC USHORT | hb_clsNew( const char * szClassName, USHORT uiDatas, PHB_ITEM pSuperArray, PHB_SYMB pClassFunc, BOOL fModuleFriendly )
static USHORT hb_clsNew( const char * szClassName, USHORT uiDatas,
PHB_ITEM pSuperArray, PHB_SYMB pClassFunc,
BOOL fModuleFriendly )
{
PCLASS pNewCls;
PMETHOD pMethod;
USHORT ui, uiSuper, uiSuperCls;
USHORT * puiClassData = NULL, uiClassDataSize = 0;
uiSuper = ( USHORT ) ( pSuperArray ? hb_arrayLen( pSuperArray ) : 0 );
pClassFunc = hb_vmGetRealFuncSym( pClassFunc );
if( s_pClasses )
s_pClasses = ( PCLASS ) hb_xrealloc( s_pClasses, sizeof( CLASS ) * ( s_uiClasses + 2 ) );
else
{
s_pClasses = ( PCLASS ) hb_xgrab( sizeof( CLASS ) * 2 );
memset( s_pClasses, 0, sizeof( CLASS ) );
}
pNewCls = s_pClasses + ++s_uiClasses;
memset( pNewCls, 0, sizeof( CLASS ) );
pNewCls->szName = hb_strdup( szClassName );
pNewCls->pClassSym = hb_dynsymGet( pNewCls->szName );
if( !pClassFunc )
pClassFunc = hb_vmGetRealFuncSym( pNewCls->pClassSym->pSymbol );
pNewCls->pClassFuncSym = pClassFunc;
if( fModuleFriendly )
hb_vmFindModuleSymbols( pClassFunc, &pNewCls->pFriendModule,
&pNewCls->uiFriendModule );
for( ui = 1; ui <= uiSuper; ++ui )
{
uiSuperCls = ( USHORT ) hb_arrayGetNI( pSuperArray, ui );
if( uiSuperCls && uiSuperCls < s_uiClasses )
{
PCLASS pSprCls;
pSprCls = &s_pClasses[ uiSuperCls ];
if( ! hb_clsInited( pNewCls ) ) /* This is the first superclass */
{
hb_clsCopyClass( pNewCls, pSprCls );
}
else if( !hb_clsHasParent( pNewCls, pSprCls->pClassSym ) )
{
ULONG ul, ulLimit;
USHORT nLenClsDatas;
/* create class data translation tables */
nLenClsDatas = ( USHORT ) hb_itemSize( pSprCls->pClassDatas );
if( nLenClsDatas )
{
if( nLenClsDatas > uiClassDataSize )
{
if( puiClassData )
puiClassData = ( USHORT * ) hb_xrealloc( puiClassData,
sizeof( USHORT ) * nLenClsDatas );
else
puiClassData = ( USHORT * ) hb_xgrab( sizeof( USHORT ) *
nLenClsDatas );
uiClassDataSize = nLenClsDatas;
}
memset( puiClassData, 0, sizeof( USHORT ) * nLenClsDatas );
}
/* Copy super classs handles */
ulLimit = hb_clsMthNum( pSprCls );
for( ul = 0; ul < ulLimit; ++ul )
{
if( pSprCls->pMethods[ ul ].pMessage &&
pSprCls->pMethods[ ul ].pFuncSym == &s___msgSuper )
{
PCLASS pCls = &s_pClasses[ pSprCls->pMethods[ ul ].uiSprClass ];
pMethod = hb_clsAllocMsg( pNewCls,
pSprCls->pMethods[ ul ].pMessage );
if( ! pMethod )
return 0;
if( pMethod->pMessage == NULL )
{
pNewCls->uiMethods++;
memcpy( pMethod, pSprCls->pMethods + ul, sizeof( METHOD ) );
pMethod->uiOffset = pNewCls->uiDatas;
pNewCls->uiDatas += pCls->uiDatas - pCls->uiDataFirst;
}
}
}
/* add class casting if not exist */
pMethod = hb_clsAllocMsg( pNewCls, pSprCls->pClassSym );
if( ! pMethod )
return 0;
if( pMethod->pMessage == NULL )
{
pNewCls->uiMethods++;
pMethod->pMessage = pSprCls->pClassSym;
pMethod->uiSprClass = uiSuperCls;
pMethod->uiScope = HB_OO_CLSTP_EXPORTED;
pMethod->pFuncSym = &s___msgSuper;
pMethod->uiOffset = pNewCls->uiDatas;
pNewCls->uiDatas += pSprCls->uiDatas - pSprCls->uiDataFirst;
}
/* Copy instance area init data */
if( pSprCls->uiInitDatas )
{
USHORT u;
for( u = 0; u < pSprCls->uiInitDatas; ++u )
{
if( pSprCls->pInitData[ u ].uiType == HB_OO_MSG_DATA )
{
USHORT uiCls = pSprCls->pInitData[ u ].uiSprClass;
hb_clsAddInitValue( pNewCls,
pSprCls->pInitData[ u ].pInitValue, HB_OO_MSG_DATA,
pSprCls->pInitData[ u ].uiData,
hb_clsParentInstanceOffset( pNewCls,
s_pClasses[ uiCls ].pClassSym ),
uiCls );
}
}
}
/* Now working on other methods */
ulLimit = hb_clsMthNum( pSprCls );
for( ul = 0; ul < ulLimit; ++ul )
{
if( pSprCls->pMethods[ ul ].pMessage )
{
pMethod = hb_clsAllocMsg( pNewCls, pSprCls->pMethods[ ul ].pMessage );
if( ! pMethod )
return 0;
/* Ok, this bucket is empty */
if( pMethod->pMessage == NULL )
{
/* Now, we can increment the msg count */
pNewCls->uiMethods++;
memcpy( pMethod, pSprCls->pMethods + ul, sizeof( METHOD ) );
if( ! hb_clsUpdateHiddenMessages( pMethod, pMethod, pNewCls ) )
{
if( pMethod->pFuncSym == &s___msgSetClsData ||
pMethod->pFuncSym == &s___msgGetClsData )
{
if( pMethod->uiData > nLenClsDatas )
hb_errInternal( HB_EI_CLSINVMETHOD, NULL, "__clsNew()", NULL );
if( puiClassData[ pMethod->uiData - 1 ] == 0 )
{
puiClassData[ pMethod->uiData - 1 ] = ( USHORT )
hb_arrayLen( pNewCls->pClassDatas ) + 1;
hb_arraySize( pNewCls->pClassDatas,
puiClassData[ pMethod->uiData - 1 ] );
}
if( pMethod->uiOffset )
{
pMethod->uiOffset = hb_clsAddInitValue( pNewCls,
pSprCls->pInitData[ pMethod->uiOffset - 1 ].pInitValue,
HB_OO_MSG_CLASSDATA, puiClassData[ pMethod->uiData - 1 ],
0, uiSuperCls );
}
pMethod->uiData = puiClassData[ pMethod->uiData - 1 ];
}
else if( pMethod->pFuncSym == &s___msgSetData ||
pMethod->pFuncSym == &s___msgGetData )
{
pMethod->uiOffset = hb_clsParentInstanceOffset( pNewCls,
s_pClasses[ pMethod->uiSprClass ].pClassSym );
}
pMethod->uiScope |= HB_OO_CLSTP_SUPER;
}
}
else
{
if( pSprCls->pMethods[ ul ].uiScope &
( HB_OO_CLSTP_OVERLOADED | HB_OO_CLSTP_NONVIRTUAL ) )
pMethod->uiScope |= HB_OO_CLSTP_OVERLOADED;
hb_clsUpdateHiddenMessages( pSprCls->pMethods + ul, pMethod, pNewCls );
}
}
}
pNewCls->ulOpFlags |= pSprCls->ulOpFlags;
}
}
}
if( puiClassData )
hb_xfree( puiClassData );
if( ! hb_clsInited( pNewCls ) )
{
hb_clsDictInit( pNewCls, HASH_KEY );
pNewCls->pClassDatas = hb_itemArrayNew( 0 );
pNewCls->pSharedDatas = hb_itemArrayNew( 0 );
pNewCls->pInlines = hb_itemArrayNew( 0 );
}
/* add self class casting */
if( hb_stricmp( pNewCls->szName, pNewCls->pClassSym->pSymbol->szName ) == 0 )
{
pMethod = hb_clsAllocMsg( pNewCls, pNewCls->pClassSym );
if( ! pMethod )
return 0;
if( pMethod->pMessage == NULL )
{
pNewCls->uiMethods++;
pMethod->pMessage = pNewCls->pClassSym;
pMethod->uiSprClass = s_uiClasses;
pMethod->uiScope = HB_OO_CLSTP_EXPORTED;
pMethod->pFuncSym = &s___msgSuper;
pMethod->uiOffset = pNewCls->uiDatas;
}
}
pNewCls->uiDataFirst = pNewCls->uiDatas;
pNewCls->uiDatas += uiDatas;
return s_uiClasses;
}
| classes.c | 2943 |
HB_FUNC | __CLSNEW(void)
HB_FUNC( __CLSNEW )
{
char * szClassName;
PHB_ITEM pDatas, pSuperArray, pClassFunc, pModFriend;
szClassName = hb_parc( 1 );
pDatas = hb_param( 2, HB_IT_ANY );
pSuperArray = hb_param( 3, HB_IT_ANY );
if( pSuperArray && HB_IS_NIL( pSuperArray ) )
pSuperArray = NULL;
pClassFunc = hb_param( 4, HB_IT_ANY );
if( pClassFunc && HB_IS_NIL( pClassFunc ) )
pClassFunc = NULL;
pModFriend = hb_param( 5, HB_IT_ANY );
if( pModFriend && HB_IS_NIL( pModFriend ) )
pModFriend = NULL;
if( szClassName &&
( ! pDatas || HB_IS_NUMERIC( pDatas ) ) &&
( ! pSuperArray || HB_IS_ARRAY( pSuperArray ) ) &&
( ! pClassFunc || HB_IS_SYMBOL( pClassFunc ) ) &&
( ! pModFriend || HB_IS_LOGICAL( pModFriend ) ) )
{
USHORT uiClass;
uiClass = hb_clsNew( szClassName, ( USHORT ) hb_itemGetNI( pDatas ),
pSuperArray, hb_itemGetSymbol( pClassFunc ),
hb_itemGetL( pModFriend ) );
hb_retni( uiClass );
}
else
hb_errRT_BASE( EG_ARG, 3000, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| classes.c | 3176 |
HB_FUNC | __CLSADDFRIEND(void)
HB_FUNC( __CLSADDFRIEND )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
if( uiClass && uiClass <= s_uiClasses )
{
PCLASS pClass = &s_pClasses[ uiClass ];
if( !pClass->fLocked )
{
PHB_SYMB pSym = hb_vmGetRealFuncSym( hb_itemGetSymbol( hb_param( 2,
HB_IT_SYMBOL ) ) );
if( pSym )
hb_clsAddFriendSymbol( pClass, pSym );
}
}
}
| classes.c | 3227 |
HB_FUNC | __CLSDELMSG(void)
HB_FUNC( __CLSDELMSG )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
PHB_ITEM pString = hb_param( 2, HB_IT_STRING );
if( uiClass && uiClass <= s_uiClasses && pString &&
! s_pClasses[ uiClass ].fLocked )
{
PHB_DYNS pMsg = hb_dynsymFindName( pString->item.asString.value );
if( pMsg )
hb_clsFreeMsg( &s_pClasses[ uiClass ], pMsg );
}
}
| classes.c | 3250 |
STATIC PHB_ITEM | hb_clsInst( USHORT uiClass )
static PHB_ITEM hb_clsInst( USHORT uiClass )
{
PHB_ITEM pSelf = NULL;
if( uiClass && uiClass <= s_uiClasses )
{
PCLASS pClass = &s_pClasses[ uiClass ];
pSelf = hb_itemNew( NULL );
hb_arrayNew( pSelf, pClass->uiDatas );
pSelf->item.asArray.value->uiClass = uiClass;
/* Initialise value if initialisation was requested */
if( pClass->uiInitDatas )
{
PINITDATA pInitData = pClass->pInitData;
USHORT ui = pClass->uiInitDatas;
PHB_ITEM pDestItm;
do
{
if( pInitData->uiType == HB_OO_MSG_DATA )
pDestItm = hb_arrayGetItemPtr( pSelf,
pInitData->uiData + pInitData->uiOffset );
else if( pInitData->uiType == HB_OO_MSG_CLASSDATA )
{
pDestItm = hb_arrayGetItemPtr( pClass->pClassDatas,
pInitData->uiData );
/* do not initialize it again */
pInitData->uiType = HB_OO_MSG_INITIALIZED;
}
else
pDestItm = NULL;
if( pDestItm )
{
PHB_ITEM pInit = hb_itemClone( pInitData->pInitValue );
hb_itemMove( pDestItm, pInit );
hb_itemRelease( pInit );
}
++pInitData;
}
while( --ui );
}
}
return pSelf;
}
| classes.c | 3274 |
HB_FUNC | __CLSINST(void)
HB_FUNC( __CLSINST )
{
PHB_ITEM pSelf = hb_clsInst( ( USHORT ) hb_parni( 1 ) );
if( pSelf )
hb_itemReturnRelease( pSelf );
}
| classes.c | 3328 |
HB_FUNC | __CLSLOCK(void)
HB_FUNC( __CLSLOCK )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
if( uiClass && uiClass <= s_uiClasses )
s_pClasses[ uiClass ].fLocked = TRUE;
}
| classes.c | 3341 |
HB_FUNC | __CLSMODMSG(void)
HB_FUNC( __CLSMODMSG )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
PHB_ITEM pString = hb_param( 2, HB_IT_STRING );
if( uiClass && uiClass <= s_uiClasses && pString &&
! s_pClasses[ uiClass ].fLocked )
{
PHB_DYNS pMsg = hb_dynsymFindName( pString->item.asString.value );
if( pMsg )
{
PCLASS pClass = &s_pClasses[ uiClass ];
PMETHOD pMethod = hb_clsFindMsg( pClass, pMsg );
if( pMethod )
{
PHB_SYMB pFuncSym = pMethod->pFuncSym;
if( pFuncSym == &s___msgSetData || pFuncSym == &s___msgGetData )
{
hb_errRT_BASE( EG_ARG, 3004, "Cannot modify a DATA item", HB_ERR_FUNCNAME, 0 );
}
else if( pFuncSym == &s___msgEvalInline )
{
PHB_ITEM pBlock = hb_param( 3, HB_IT_BLOCK );
if( pBlock == NULL )
hb_errRT_BASE( EG_ARG, 3000, "Cannot modify INLINE method", HB_ERR_FUNCNAME, 0 );
else
hb_arraySet( s_pClasses[ pMethod->uiSprClass ].pInlines,
pMethod->uiData, pBlock );
}
else /* Modify METHOD */
{
pFuncSym = hb_objGetFuncSym( hb_param( 3, HB_IT_ANY ) );
if( pFuncSym == NULL )
hb_errRT_BASE( EG_ARG, 3000, NULL, HB_ERR_FUNCNAME, 0 );
else
pMethod->pFuncSym = pFuncSym;
}
}
}
}
}
| classes.c | 3353 |
HB_FUNC | __OBJGETCLSNAME(void)
HB_FUNC( __OBJGETCLSNAME )
{
PHB_ITEM pObject = hb_param( 1, HB_IT_OBJECT );
USHORT uiClass;
if( pObject )
uiClass = pObject->item.asArray.value->uiClass;
else
uiClass = ( USHORT ) hb_parni( 1 );
hb_retc( hb_clsName( uiClass ) );
}
| classes.c | 3406 |
HB_FUNC | __OBJHASMSG(void)
HB_FUNC( __OBJHASMSG )
{
PHB_DYNS pMessage = hb_objGetMsgSym( hb_param( 2, HB_IT_ANY ) );
if( pMessage )
hb_retl( hb_objHasMessage( hb_param( 1, HB_IT_ANY ), pMessage ) );
else
hb_errRT_BASE_SubstR( EG_ARG, 1099, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| classes.c | 3425 |
HB_FUNC | __OBJSENDMSG(void)
HB_FUNC( __OBJSENDMSG )
{
PHB_DYNS pMessage = hb_objGetMsgSym( hb_param( 2, HB_IT_ANY ) );
if( pMessage )
{
USHORT uiPCount = hb_pcount();
USHORT uiParam;
hb_vmPushSymbol( pMessage->pSymbol ); /* Push message symbol */
hb_vmPush( hb_param( 1, HB_IT_ANY ) ); /* Push object */
for( uiParam = 3; uiParam <= uiPCount; ++uiParam ) /* Push arguments on stack */
{
hb_vmPush( hb_stackItemFromBase( uiParam ) );
}
hb_vmSend( ( USHORT ) ( uiPCount - 2 ) ); /* Execute message */
}
else
{
hb_errRT_BASE( EG_ARG, 3000, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
}
| classes.c | 3440 |
HB_FUNC | __OBJCLONE(void)
HB_FUNC( __OBJCLONE )
{
PHB_ITEM pSrcObject = hb_param( 1, HB_IT_OBJECT );
PHB_ITEM pDstObject;
if( pSrcObject )
{
pDstObject = hb_arrayClone( pSrcObject );
hb_itemReturnRelease( pDstObject );
}
else
{
hb_errRT_BASE( EG_ARG, 3001, NULL, HB_ERR_FUNCNAME, 0 );
}
}
| classes.c | 3469 |
HB_FUNC | __CLSINSTSUPER(void)
HB_FUNC( __CLSINSTSUPER )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_STRING | HB_IT_SYMBOL );
USHORT uiClassH = 0, uiClass;
PHB_SYMB pClassFuncSym = NULL;
if( pItem )
{
if( HB_IS_SYMBOL( pItem ) )
pClassFuncSym = hb_itemGetSymbol( pItem );
else if( HB_IS_STRING( pItem ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( hb_itemGetCPtr( pItem ) );
if( pDynSym )
pClassFuncSym = pDynSym->pSymbol;
}
pClassFuncSym = hb_vmGetRealFuncSym( pClassFuncSym );
}
if( pClassFuncSym )
{
uiClassH = hb_clsFindClassByFunc( pClassFuncSym );
if( uiClassH == 0 )
{
hb_vmPushSymbol( pClassFuncSym );
hb_vmPushNil();
hb_vmFunction( 0 ); /* Execute super class */
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pObject = hb_stackReturnItem();
if( HB_IS_OBJECT( pObject ) )
{
uiClass = pObject->item.asArray.value->uiClass;
if( s_pClasses[ uiClass ].pClassFuncSym == pClassFuncSym )
uiClassH = uiClass;
else
{
uiClassH = hb_clsFindClassByFunc( pClassFuncSym );
/* still not found, try to send NEW() message */
if( uiClassH == 0 )
{
hb_vmPushSymbol( &s___msgNew );
hb_vmPush( pObject );
hb_vmSend( 0 );
pObject = hb_stackReturnItem();
if( HB_IS_OBJECT( pObject ) )
{
uiClass = pObject->item.asArray.value->uiClass;
if( s_pClasses[ uiClass ].pClassFuncSym == pClassFuncSym )
uiClassH = uiClass;
}
}
}
}
/* This disables destructor execution for this object */
if( uiClassH && HB_IS_OBJECT( pObject ) )
pObject->item.asArray.value->uiClass = 0;
else if( hb_vmRequestQuery() == 0 )
hb_errRT_BASE( EG_ARG, 3002, "Super class does not return an object", HB_ERR_FUNCNAME, 0 );
}
}
}
else
hb_errRT_BASE( EG_ARG, 3003, "Cannot find super class", HB_ERR_FUNCNAME, 0 );
hb_retni( uiClassH );
}
| classes.c | 3490 |
HB_FUNC | __CLSASSOCTYPE(void)
HB_FUNC( __CLSASSOCTYPE )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
PHB_ITEM pType = hb_param( 2, HB_IT_ANY );
BOOL fResult = FALSE;
if( uiClass && uiClass <= s_uiClasses && pType )
{
HB_TYPE nType = hb_clsGetItemType( pType, HB_IT_ANY );
if( nType != HB_IT_ANY )
{
switch( nType )
{
case HB_IT_ARRAY:
s_uiArrayClass = uiClass;
break;
case HB_IT_BLOCK:
s_uiBlockClass = uiClass;
break;
case HB_IT_STRING:
s_uiCharacterClass = uiClass;
break;
case HB_IT_DATE:
s_uiDateClass = uiClass;
break;
case HB_IT_HASH:
s_uiHashClass = uiClass;
break;
case HB_IT_LOGICAL:
s_uiLogicalClass = uiClass;
break;
case HB_IT_NIL:
s_uiNilClass = uiClass;
break;
case HB_IT_NUMERIC:
s_uiNumericClass = uiClass;
break;
case HB_IT_SYMBOL:
s_uiSymbolClass = uiClass;
break;
case HB_IT_POINTER:
s_uiPointerClass = uiClass;
break;
default:
uiClass = 0;
}
fResult = uiClass != 0;
}
}
hb_retl( fResult );
}
| classes.c | 3568 |
HB_FUNC | __CLSCNTCLASSES(void)
HB_FUNC( __CLSCNTCLASSES )
{
hb_retni( ( int ) s_uiClasses );
}
| classes.c | 3626 |
HB_FUNC | __CLS_CNTCLSDATA(void)
HB_FUNC( __CLS_CNTCLSDATA )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
hb_retni( uiClass && uiClass <= s_uiClasses ?
hb_arrayLen( s_pClasses[ uiClass ].pClassDatas ) : 0 );
}
| classes.c | 3636 |
HB_FUNC | __CLS_CNTSHRDATA(void)
HB_FUNC( __CLS_CNTSHRDATA )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
hb_retni( uiClass && uiClass <= s_uiClasses ?
hb_arrayLen( s_pClasses[ uiClass ].pSharedDatas ) : 0 );
}
| classes.c | 3649 |
HB_FUNC | __CLS_CNTDATA(void)
HB_FUNC( __CLS_CNTDATA )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
hb_retni( uiClass && uiClass <= s_uiClasses ?
s_pClasses[ uiClass ].uiDatas : 0 );
}
| classes.c | 3662 |
HB_FUNC | __CLS_DECDATA(void)
HB_FUNC( __CLS_DECDATA )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
if( uiClass && uiClass <= s_uiClasses &&
s_pClasses[ uiClass ].uiDatas > s_pClasses[ uiClass ].uiDataFirst )
{
if( !s_pClasses[ uiClass ].fLocked )
s_pClasses[ uiClass ].uiDatas--;
hb_retni( s_pClasses[ uiClass ].uiDatas - s_pClasses[ uiClass ].uiDataFirst );
}
else
hb_retni( 0 );
}
| classes.c | 3675 |
HB_FUNC | __CLS_INCDATA(void)
HB_FUNC( __CLS_INCDATA )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
if( uiClass && uiClass <= s_uiClasses )
{
if( !s_pClasses[ uiClass ].fLocked )
s_pClasses[ uiClass ].uiDatas++;
hb_retni( s_pClasses[ uiClass ].uiDatas - s_pClasses[ uiClass ].uiDataFirst );
}
else
hb_retni( 0 );
}
| classes.c | 3695 |
HB_FUNC | __CLASSNEW(void)
HB_FUNC( __CLASSNEW )
{
HB_FUNC_EXEC( __CLSNEW );
}
| classes.c | 3715 |
HB_FUNC | __CLASSINSTANCE(void)
HB_FUNC( __CLASSINSTANCE )
{
HB_FUNC_EXEC( __CLSINST );
}
| classes.c | 3724 |
HB_FUNC | __CLASSADD(void)
HB_FUNC( __CLASSADD )
{
HB_FUNC_EXEC( __CLSADDMSG );
}
| classes.c | 3732 |
HB_FUNC | __CLASSNAME(void)
HB_FUNC( __CLASSNAME )
{
hb_retc( hb_clsName( ( USHORT ) hb_parni( 1 ) ) );
}
| classes.c | 3740 |
HB_FUNC | __CLASSSEL(void)
HB_FUNC( __CLASSSEL )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
PHB_ITEM pReturn = hb_itemNew( NULL );
if( uiClass && uiClass <= s_uiClasses )
{
PCLASS pClass = &s_pClasses[ uiClass ];
PMETHOD pMethod = pClass->pMethods;
ULONG ulLimit = hb_clsMthNum( pClass ), ulPos = 0;
hb_arrayNew( pReturn, pClass->uiMethods ); /* Create a transfer array */
do
{
if( pMethod->pMessage ) /* Hash Entry used ? */
hb_arraySetC( pReturn, ++ulPos, pMethod->pMessage->pSymbol->szName );
++pMethod;
}
while( --ulLimit );
if( ulPos < ( ULONG ) pClass->uiMethods )
hb_arraySize( pReturn, ulPos );
}
hb_itemReturnRelease( pReturn );
}
| classes.c | 3747 |
HB_FUNC | __GETMESSAGE(void)
HB_FUNC( __GETMESSAGE )
{
hb_retc( hb_stackItem( hb_stackBaseItem()->item.asSymbol.stackstate->lBaseItem )->item.asSymbol.value->szName );
}
| classes.c | 3775 |
HB_FUNC | __CLSPARENT(void)
HB_FUNC( __CLSPARENT )
{
hb_retl( hb_clsIsParent( hb_parni( 1 ) , hb_parc( 2 ) ) );
}
| classes.c | 3781 |
HB_FUNC | __SENDER(void)
HB_FUNC( __SENDER )
{
LONG lOffset = hb_stackBaseProcOffset( 2 );
if( lOffset > 0 )
{
PHB_ITEM pSelf = hb_stackItem( lOffset + 1 );
/* Is it inline method? */
if( lOffset > 0 && HB_IS_BLOCK( pSelf ) &&
hb_stackItem( lOffset )->item.asSymbol.value == &hb_symEval )
{
pSelf = hb_stackItem( hb_stackItem( lOffset )->
item.asSymbol.stackstate->lBaseItem + 1 );
}
if( HB_IS_OBJECT( pSelf ) )
{
hb_itemReturn( pSelf );
}
}
}
| classes.c | 3786 |
HB_FUNC | __CLASSH(void)
HB_FUNC( __CLASSH )
{
PHB_ITEM pObject = hb_param( 1, HB_IT_ANY );
hb_retni( pObject ? hb_objGetClassH( pObject ) : 0 );
}
| classes.c | 3809 |
STATIC HARBOUR | hb___msgClassH( void )
static HARBOUR hb___msgClassH( void )
{
hb_retni( hb_stackBaseItem()->item.asSymbol.stackstate->uiClass );
}
| classes.c | 3823 |
STATIC HARBOUR | hb___msgClassName( void )
static HARBOUR hb___msgClassName( void )
{
USHORT uiClass = hb_stackBaseItem()->item.asSymbol.stackstate->uiClass;
if( uiClass )
hb_retc( s_pClasses[ uiClass ].szName );
else
hb_retc( hb_objGetClsName( hb_stackSelfItem() ) );
}
| classes.c | 3834 |
STATIC HARBOUR | hb___msgClassSel( void )
static HARBOUR hb___msgClassSel( void )
{
USHORT uiClass = hb_stackBaseItem()->item.asSymbol.stackstate->uiClass;
if( uiClass && uiClass <= s_uiClasses )
{
PHB_ITEM pReturn = hb_itemNew( NULL );
PCLASS pClass = &s_pClasses[ uiClass ];
PMETHOD pMethod = pClass->pMethods;
ULONG ulLimit = hb_clsMthNum( pClass ), ulPos = 0;
USHORT nParam;
nParam = hb_pcount() > 0 ? ( USHORT ) hb_parni( 1 ) : HB_MSGLISTALL;
hb_arrayNew( pReturn, pClass->uiMethods );
do
{
if( pMethod->pMessage ) /* Hash Entry used ? */
{
if( ( nParam == HB_MSGLISTALL ) ||
( nParam == HB_MSGLISTCLASS &&
(
( pMethod->pFuncSym == &s___msgSetClsData ) ||
( pMethod->pFuncSym == &s___msgGetClsData ) ||
( pMethod->pFuncSym == &s___msgSetShrData ) ||
( pMethod->pFuncSym == &s___msgGetShrData )
)
) ||
( nParam == HB_MSGLISTPURE &&
!(
( pMethod->pFuncSym == &s___msgSetClsData ) ||
( pMethod->pFuncSym == &s___msgGetClsData ) ||
( pMethod->pFuncSym == &s___msgSetShrData ) ||
( pMethod->pFuncSym == &s___msgGetShrData )
)
)
)
{
hb_arraySetC( pReturn, ++ulPos,
pMethod->pMessage->pSymbol->szName );
}
}
++pMethod;
}
while( --ulLimit && ulPos < ( ULONG ) pClass->uiMethods );
if( ulPos < ( ULONG ) pClass->uiMethods )
hb_arraySize( pReturn, ulPos );
hb_itemReturnRelease( pReturn );
}
}
| classes.c | 3850 |
STATIC HARBOUR | hb___msgClass( void )
static HARBOUR hb___msgClass( void )
{
hb_itemReturnForward( hb_stackSelfItem() );
}
| classes.c | 3909 |
STATIC HARBOUR | hb___msgClassParent( void )
static HARBOUR hb___msgClassParent( void )
{
char * szParentName = NULL;
PHB_ITEM pItem;
USHORT uiClass;
uiClass = hb_stackBaseItem()->item.asSymbol.stackstate->uiClass;
pItemParam = hb_param( 1, HB_IT_ANY );
if( pItemParam )
{
if( HB_IS_OBJECT( pItemParam ) )
szParentName = hb_objGetClsName( pItemParam );
else if( HB_IS_STRING( pItemParam ) )
szParentName = hb_parc( pItemParam );
}
hb_retl( szParentName && hb_clsIsParent( uiClass , szParentName ) );
}
| classes.c | 3919 |
STATIC HARBOUR | hb___msgEvalInline( void )
static HARBOUR hb___msgEvalInline( void )
{
PHB_STACK_STATE pStack = hb_stackBaseItem()->item.asSymbol.stackstate;
PCLASS pClass = &s_pClasses[ pStack->uiClass ];
PMETHOD pMethod = pClass->pMethods + pStack->uiMethod;
USHORT uiPCount = hb_pcount(), uiParam;
PHB_ITEM pBlock;
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( hb_arrayGetItemPtr( s_pClasses[ pMethod->uiSprClass ].pInlines,
pMethod->uiData ) );
pBlock = hb_stackItemFromTop( -1 ); /* Push block */
pBlock->item.asBlock.hclass = pStack->uiClass;
pBlock->item.asBlock.method = pStack->uiMethod;
hb_vmPush( hb_stackSelfItem() ); /* Push self as first argument */
for( uiParam = 1; uiParam <= uiPCount; uiParam++ )
{
hb_vmPush( hb_stackItemFromBase( uiParam ) );
}
hb_vmSend( uiPCount + 1 );
}
| classes.c | 3948 |
STATIC HARBOUR | hb___msgPerform( void )
static HARBOUR hb___msgPerform( void )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_ANY );
USHORT uiPCount = hb_pcount(), uiParam;
PHB_SYMB pSym = NULL;
if( pItem )
{
if( HB_IS_SYMBOL( pItem ) )
pSym = pItem->item.asSymbol.value;
else if( HB_IS_OBJECT( pItem ) &&
s_pClasses[ pItem->item.asArray.value->uiClass ].pClassSym ==
s___msgSymbol.pDynSym )
{
/* Dirty hack */
pItem = hb_arrayGetItemPtr( pItem, 1 );
if( pItem && HB_IS_SYMBOL( pItem ) )
pSym = pItem->item.asSymbol.value;
}
if( pSym )
{
hb_vmPushSymbol( pSym );
hb_vmPush( hb_stackSelfItem() );
for( uiParam = 2; uiParam <= uiPCount; uiParam++ )
{
hb_vmPush( hb_stackItemFromBase( uiParam ) );
}
hb_vmSend( uiPCount - 1 );
}
}
}
| classes.c | 3979 |
STATIC HARBOUR | hb___msgDelegate( void )
static HARBOUR hb___msgDelegate( void )
{
PCLASS pClass = &s_pClasses[
hb_stackBaseItem()->item.asSymbol.stackstate->uiClass ];
PMETHOD pMethod = pClass->pMethods +
hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
PHB_SYMB pExecSym = pClass->pMethods[ pMethod->uiData ].pFuncSym;
if( pExecSym && pExecSym->value.pFunPtr )
{
if( pExecSym->scope.value & HB_FS_PCODEFUNC )
/* Running pCode dynamic function from .HRB */
hb_vmExecute( pExecSym->value.pCodeFunc->pCode,
pExecSym->value.pCodeFunc->pSymbols );
else
pExecSym->value.pFunPtr();
}
else
{
hb___msgNoMethod();
}
}
| classes.c | 4014 |
STATIC HARBOUR | hb___msgNoMethod( void )
static HARBOUR hb___msgNoMethod( void )
{
PHB_SYMB pSym = hb_itemGetSymbol( hb_stackBaseItem() );
#if 1 /* Clipper compatible error message */
if( pSym->szName[ 0 ] == '_' )
hb_errRT_BASE_SubstR( EG_NOVARMETHOD, 1005, NULL, pSym->szName + 1, HB_ERR_ARGS_SELFPARAMS );
else
hb_errRT_BASE_SubstR( EG_NOMETHOD, 1004, NULL, pSym->szName, HB_ERR_ARGS_SELFPARAMS );
#else
char szDesc[ 128 ];
if( pSym->szName[ 0 ] == '_' )
{
snprintf( szDesc, sizeof( szDesc ), "Class: '%s' has no property", hb_objGetClsName( hb_stackSelfItem() ) );
hb_errRT_BASE_SubstR( EG_NOVARMETHOD, 1005, szDesc, pSym->szName + 1, HB_ERR_ARGS_BASEPARAMS );
}
else
{
snprintf( szDesc, sizeof( szDesc ), "Class: '%s' has no exported method", hb_objGetClsName( hb_stackSelfItem() ) );
hb_errRT_BASE_SubstR( EG_NOMETHOD, 1004, szDesc, pSym->szName, HB_ERR_ARGS_BASEPARAMS );
}
#endif
}
| classes.c | 4037 |
STATIC HARBOUR | hb___msgScopeErr( void )
static HARBOUR hb___msgScopeErr( void )
{
char * pszProcName;
PHB_ITEM pObject = hb_stackSelfItem();
PMETHOD pMethod = s_pClasses[
hb_stackBaseItem()->item.asSymbol.stackstate->uiClass ].pMethods +
hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
pszProcName = hb_xstrcpy( NULL, hb_objGetClsName( pObject ), ":",
pMethod->pMessage->pSymbol->szName, NULL );
if( pMethod->uiScope & HB_OO_CLSTP_HIDDEN )
hb_errRT_BASE( EG_NOMETHOD, 41, "Scope violation (hidden)", pszProcName, 0 );
else
hb_errRT_BASE( EG_NOMETHOD, 42, "Scope violation (protected)", pszProcName, 0 );
hb_xfree( pszProcName );
}
| classes.c | 4067 |
STATIC HARBOUR | hb___msgTypeErr( void )
static HARBOUR hb___msgTypeErr( void )
{
char * pszProcName;
PHB_ITEM pObject = hb_stackSelfItem();
PMETHOD pMethod = s_pClasses[
hb_stackBaseItem()->item.asSymbol.stackstate->uiClass ].pMethods +
hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
pszProcName = hb_xstrcpy( NULL, hb_objGetClsName( pObject ), ":",
pMethod->pMessage->pSymbol->szName + 1, NULL );
hb_errRT_BASE( EG_NOMETHOD, 44, "Assigned value is wrong class", pszProcName, HB_ERR_ARGS_BASEPARAMS );
hb_xfree( pszProcName );
}
| classes.c | 4089 |
STATIC HARBOUR | hb___msgSuper( void )
static HARBOUR hb___msgSuper( void )
{
PHB_STACK_STATE pStack = hb_stackBaseItem()->item.asSymbol.stackstate;
hb_clsMakeSuperObject( hb_stackReturnItem(), hb_stackSelfItem(),
s_pClasses[ pStack->uiClass ].pMethods[ pStack->uiMethod ].uiSprClass );
}
| classes.c | 4103 |
STATIC HARBOUR | hb___msgRealClass( void )
static HARBOUR hb___msgRealClass( void )
{
PHB_ITEM pObject = hb_stackSelfItem();
USHORT uiClass = hb_clsSenderMethodClasss();
USHORT uiCurClass = hb_objGetClassH( pObject );
if( uiClass && uiClass != uiCurClass &&
hb_clsSenderObjectClasss() == uiCurClass )
{
hb_clsMakeSuperObject( hb_stackReturnItem(), pObject, uiClass );
}
else
{
hb_itemReturnForward( pObject );
}
}
| classes.c | 4116 |
STATIC HARBOUR | hb___msgGetClsData( void )
static HARBOUR hb___msgGetClsData( void )
{
PCLASS pClass = &s_pClasses[
hb_stackBaseItem()->item.asSymbol.stackstate->uiClass ];
PMETHOD pMethod = pClass->pMethods +
hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
hb_arrayGet( pClass->pClassDatas, pMethod->uiData, hb_stackReturnItem() );
}
| classes.c | 4139 |
STATIC HARBOUR | hb___msgSetClsData( void )
static HARBOUR hb___msgSetClsData( void )
{
PCLASS pClass = &s_pClasses[
hb_stackBaseItem()->item.asSymbol.stackstate->uiClass ];
PMETHOD pMethod = pClass->pMethods +
hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
PHB_ITEM pReturn = hb_param( 1, HB_IT_ANY );
if( !pReturn )
hb_arrayGet( pClass->pClassDatas, pMethod->uiData, hb_stackReturnItem() );
else
{
if( pMethod->itemType &&
! ( pMethod->itemType & HB_ITEM_TYPERAW( pReturn ) ) )
{
if( pMethod->itemType == HB_IT_NUMINT && HB_IS_NUMERIC( pReturn ) )
hb_itemPutNInt( pReturn, hb_itemGetNInt( pReturn ) );
else
{
(s___msgTypeErr.value.pFunPtr)();
return;
}
}
hb_arraySet( pClass->pClassDatas, pMethod->uiData, pReturn );
hb_itemReturnForward( pReturn );
}
}
| classes.c | 4155 |
STATIC HARBOUR | hb___msgGetShrData( void )
static HARBOUR hb___msgGetShrData( void )
{
PCLASS pClass = &s_pClasses[
hb_stackBaseItem()->item.asSymbol.stackstate->uiClass ];
PMETHOD pMethod = pClass->pMethods +
hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
hb_arrayGet( s_pClasses[ pMethod->uiSprClass ].pSharedDatas,
pMethod->uiData, hb_stackReturnItem() );
}
| classes.c | 4190 |
STATIC HARBOUR | hb___msgSetShrData( void )
static HARBOUR hb___msgSetShrData( void )
{
PCLASS pClass = &s_pClasses[
hb_stackBaseItem()->item.asSymbol.stackstate->uiClass ];
PMETHOD pMethod = pClass->pMethods +
hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
PHB_ITEM pReturn = hb_param( 1, HB_IT_ANY );
if( !pReturn )
hb_arrayGet( s_pClasses[ pMethod->uiSprClass ].pSharedDatas,
pMethod->uiData, hb_stackReturnItem() );
else
{
if( pMethod->itemType &&
! ( pMethod->itemType & HB_ITEM_TYPERAW( pReturn ) ) )
{
if( pMethod->itemType == HB_IT_NUMINT && HB_IS_NUMERIC( pReturn ) )
hb_itemPutNInt( pReturn, hb_itemGetNInt( pReturn ) );
else
{
(s___msgTypeErr.value.pFunPtr)();
return;
}
}
hb_arraySet( s_pClasses[ pMethod->uiSprClass ].pSharedDatas,
pMethod->uiData, pReturn );
hb_itemReturnForward( pReturn );
}
}
| classes.c | 4206 |
STATIC HARBOUR | hb___msgGetData( void )
static HARBOUR hb___msgGetData( void )
{
PHB_ITEM pObject = hb_stackSelfItem();
if( HB_IS_ARRAY( pObject ) )
{
USHORT uiObjClass = pObject->item.asArray.value->uiClass;
USHORT uiClass = hb_stackBaseItem()->item.asSymbol.stackstate->uiClass;
PCLASS pClass = &s_pClasses[ uiClass ];
PMETHOD pMethod = pClass->pMethods +
hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
ULONG ulIndex = pMethod->uiData;
if( uiClass != uiObjClass )
{
ulIndex += hb_clsParentInstanceOffset( &s_pClasses[ uiObjClass ],
s_pClasses[ pMethod->uiSprClass ].pClassSym );
}
else
{
ulIndex += pMethod->uiOffset;
}
hb_arrayGet( pObject, ulIndex, hb_stackReturnItem() );
}
}
| classes.c | 4242 |
STATIC HARBOUR | hb___msgSetData( void )
static HARBOUR hb___msgSetData( void )
{
PHB_ITEM pObject = hb_stackSelfItem();
if( HB_IS_ARRAY( pObject ) )
{
PHB_ITEM pReturn = hb_param( 1, HB_IT_ANY );
USHORT uiObjClass = pObject->item.asArray.value->uiClass;
USHORT uiClass = hb_stackBaseItem()->item.asSymbol.stackstate->uiClass;
PCLASS pClass = &s_pClasses[ uiClass ];
PMETHOD pMethod = pClass->pMethods +
hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
ULONG ulIndex = pMethod->uiData;
if( uiClass != uiObjClass )
{
ulIndex += hb_clsParentInstanceOffset( &s_pClasses[ uiObjClass ],
s_pClasses[ pMethod->uiSprClass ].pClassSym );
}
else
{
ulIndex += pMethod->uiOffset;
}
if( !pReturn )
hb_arrayGet( pObject, ulIndex, hb_stackReturnItem() );
else
{
if( pMethod->itemType &&
! ( pMethod->itemType & HB_ITEM_TYPERAW( pReturn ) ) )
{
if( pMethod->itemType == HB_IT_NUMINT && HB_IS_NUMERIC( pReturn ) )
hb_itemPutNInt( pReturn, hb_itemGetNInt( pReturn ) );
else
{
(s___msgTypeErr.value.pFunPtr)();
return;
}
}
/* will arise only if the class has been modified after first instance */
if( ulIndex > hb_arrayLen( pObject ) ) /* Resize needed ? */
hb_arraySize( pObject, ulIndex ); /* Make large enough */
hb_arraySet( pObject, ulIndex, pReturn );
hb_itemReturnForward( pReturn );
}
}
}
| classes.c | 4274 |
STATIC HARBOUR | hb___msgVirtual( void )
static HARBOUR hb___msgVirtual( void )
{
/* hb_ret(); */ /* NOTE: It's safe to comment this out */
;
}
| classes.c | 4329 |
STATIC HARBOUR | hb___msgNull( void )
static HARBOUR hb___msgNull( void )
{
;
}
| classes.c | 4336 |
VOID | hb_mthAddTime( ULONG ulClockTicks )
void hb_mthAddTime( ULONG ulClockTicks )
{
PMETHOD pMethod = s_pClasses[ hb_objGetClassH( hb_stackSelfItem() ) ].
pMethods;
if( pMethod )
{
pMethod += hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
pMethod->ulCalls++;
pMethod->ulTime += ulClockTicks;
}
}
| classes.c | 4342 |
HB_FUNC | __GETMSGPRF(void)
HB_FUNC( __GETMSGPRF ) /* profiler: returns a method called and consumed times */
/* ( nClass, cMsg ) --> aMethodInfo { nTimes, nTime } */
{
#ifndef HB_NO_PROFILER
USHORT uiClass = ( USHORT ) hb_parni( 1 );
char * cMsg = hb_parc( 2 );
hb_reta( 2 );
if( uiClass && uiClass <= s_uiClasses && cMsg && *cMsg )
{
PHB_DYNS pMsg = hb_dynsymFindName( cMsg );
if( pMsg )
{
PMETHOD pMethod = hb_clsFindMsg( &s_pClasses[ uiClass ], pMsg );
if( pMethod )
{
hb_stornl( pMethod->ulCalls, -1, 1 );
hb_stornl( pMethod->ulTime, -1, 2 );
return;
}
}
}
#else
hb_reta( 2 );
#endif
hb_stornl( 0, -1, 1 );
hb_stornl( 0, -1, 2 );
}
| classes.c | 4355 |
HB_FUNC | __CLSGETPROPERTIES(void)
HB_FUNC( __CLSGETPROPERTIES )
{
USHORT uiClass = ( USHORT ) hb_parni( 1 );
PHB_ITEM pReturn = hb_itemNew( NULL );
if( uiClass && uiClass <= s_uiClasses )
{
PCLASS pClass = &s_pClasses[ uiClass ];
PMETHOD pMethod;
ULONG ulLimit, ulCount;
ulCount = 0;
ulLimit = hb_clsMthNum( pClass );
pMethod = pClass->pMethods;
do
{
if( pMethod->pMessage && ( pMethod->uiScope & HB_OO_CLSTP_PERSIST ) )
++ulCount;
++pMethod;
}
while( --ulLimit );
hb_arrayNew( pReturn, ulCount );
ulCount = 0;
ulLimit = hb_clsMthNum( pClass );
pMethod = pClass->pMethods;
do
{
if( pMethod->pMessage && ( pMethod->uiScope & HB_OO_CLSTP_PERSIST ) )
hb_arraySetC( pReturn, ++ulCount, pMethod->pMessage->pSymbol->szName );
++pMethod;
}
while( --ulLimit );
}
hb_itemReturnRelease( pReturn );
}
| classes.c | 4391 |
HB_FUNC | HB_SETCLSHANDLE(void)
HB_FUNC( HB_SETCLSHANDLE ) /* ( oObject, nClassHandle ) --> nPrevClassHandle */
{
PHB_ITEM pObject = hb_param( 1, HB_IT_OBJECT );
USHORT uiPrevClassHandle = 0;
if( pObject )
{
USHORT uiClass = ( USHORT ) hb_parni( 2 );
uiPrevClassHandle = pObject->item.asArray.value->uiClass;
if( uiClass <= s_uiClasses )
pObject->item.asArray.value->uiClass = uiClass;
}
hb_retnl( uiPrevClassHandle );
}
| classes.c | 4435 |
USHORT | hb_clsCreate( USHORT usSize, const char * szClassName )
USHORT hb_clsCreate( USHORT usSize, const char * szClassName )
{
return hb_clsNew( szClassName, usSize, NULL, NULL, FALSE );
}
| classes.c | 4452 |
VOID | hb_clsAdd( USHORT usClassH, const char * szMethodName, PHB_FUNC pFuncPtr )
void hb_clsAdd( USHORT usClassH, const char * szMethodName, PHB_FUNC pFuncPtr )
{
PHB_SYMB pExecSym;
PHB_ITEM pFuncItem;
/*
* We can use empty name "" for this symbol in hb_symbolNew()
* It's only envelop for function with additional execution
* information for HVM not registered symbol. [druzus]
*/
pExecSym = hb_symbolNew( "" );
pExecSym->value.pFunPtr = pFuncPtr;
pFuncItem = hb_itemPutSymbol( NULL, pExecSym );
hb_clsAddMsg( usClassH, szMethodName, HB_OO_MSG_METHOD, 0, pFuncItem, NULL );
hb_itemRelease( pFuncItem );
}
| classes.c | 4458 |
VOID | hb_clsAssociate( USHORT usClassH )
void hb_clsAssociate( USHORT usClassH )
{
PHB_ITEM pSelf = hb_clsInst( usClassH );
if( pSelf )
hb_itemReturnRelease( pSelf );
}
| classes.c | 4478 |
HB_FUNC | __CLS_PARAM(void)
HB_FUNC( __CLS_PARAM )
{
PHB_ITEM array;
USHORT uiParam = ( USHORT ) hb_pcount();
USHORT n;
if( uiParam >= 1 )
{
array = hb_itemArrayNew( uiParam );
for( n = 1; n <= uiParam; n++ )
hb_arraySet( array, n, hb_param( n, HB_IT_ANY ) );
}
else
{
array = hb_itemArrayNew( 1 );
hb_arraySetC( array, 1, "HBObject" );
}
hb_itemReturnRelease( array );
}
| classes.c | 4488 |
HB_FUNC | __CLS_PAR00(void)
HB_FUNC( __CLS_PAR00 )
{
PHB_ITEM array;
USHORT uiParam = ( USHORT ) hb_pcount();
USHORT n;
array = hb_itemArrayNew( uiParam );
for( n = 1; n <= uiParam; n++ )
hb_arraySet( array, n, hb_param( n, HB_IT_ANY ) );
hb_itemReturnRelease( array );
}
/*
* This function is only for backward binary compatibility
* It will be removed in the future so please do not use it.
* Use hb_objHasMessage() instead.
*/
#if defined(__cplusplus)
extern "C" BOOL hb_objGetpMethod( PHB_ITEM pObject, PHB_SYMB pMessage );
| classes.c | 4514 |
BOOL | hb_objGetpMethod( PHB_ITEM pObject, PHB_SYMB pMessage )
BOOL hb_objGetpMethod( PHB_ITEM pObject, PHB_SYMB pMessage )
{
return hb_objHasMessage( pObject, pMessage->pDynSym );
}
| classes.c | 4535 |
CONST CHAR * | hb_clsRealMethodName( void )
const char * hb_clsRealMethodName( void )
{
LONG lOffset = hb_stackBaseProcOffset( 1 );
const char * szName = NULL;
if( lOffset > 0 )
{
PHB_STACK_STATE pStack = hb_stackItem( lOffset )->item.asSymbol.stackstate;
if( pStack->uiClass && pStack->uiClass <= s_uiClasses )
{
PCLASS pClass = &s_pClasses[ pStack->uiClass ];
if( ( ULONG ) pStack->uiMethod < hb_clsMthNum( pClass ) )
{
PMETHOD pMethod = pClass->pMethods + pStack->uiMethod;
if( pMethod->pMessage )
szName = pMethod->pMessage->pSymbol->szName;
}
}
}
return szName;
}
| classes.c | 4543 |
cmdarg.c |
Type | Function | Source | Line |
HB_EXTERN_END HB_EXPORT VOID | hb_winmainArgInit( HANDLE hInstance, HANDLE hPrevInstance, int iCmdShow )
HB_EXPORT void hb_winmainArgInit( HANDLE hInstance, HANDLE hPrevInstance, int iCmdShow )
{
hb_hInstance = hInstance;
hb_hPrevInstance = hPrevInstance;
s_iCmdShow = iCmdShow;
s_WinMainParam = TRUE;
}
| cmdarg.c | 78 |
HB_EXPORT BOOL | hb_winmainArgGet( HANDLE * phInstance, HANDLE * phPrevInstance, int * piCmdShow )
HB_EXPORT BOOL hb_winmainArgGet( HANDLE * phInstance, HANDLE * phPrevInstance, int * piCmdShow )
{
if( phInstance )
*phInstance = hb_hInstance;
if( phPrevInstance )
*phPrevInstance = hb_hPrevInstance;
if( piCmdShow )
*piCmdShow = s_iCmdShow;
return s_WinMainParam;
}
| cmdarg.c | 86 |
HB_EXPORT VOID | hb_cmdargInit( int argc, char * argv[] )
HB_EXPORT void hb_cmdargInit( int argc, char * argv[] )
{
HB_TRACE(HB_TR_DEBUG, ("hb_cmdargInit(%d, %p)", argc, argv));
s_argc = argc;
s_argv = argv;
}
| cmdarg.c | 100 |
INT | hb_cmdargARGC( void )
int hb_cmdargARGC( void )
{
return s_argc;
}
| cmdarg.c | 108 |
CHAR ** | hb_cmdargARGV( void )
char ** hb_cmdargARGV( void )
{
return s_argv;
}
| cmdarg.c | 113 |
BOOL | hb_cmdargIsInternal( const char * szArg, int * piLen )
BOOL hb_cmdargIsInternal( const char * szArg, int * piLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_cmdargIsInternal(%s, %p)", szArg, piLen));
/* NOTE: Not checking for '--' here, as it would filter out
valid command line options used by applications. [vszakats] */
if( hb_strnicmp( szArg, "--hb:", 5 ) == 0 ||
hb_strnicmp( szArg, "//hb:", 5 ) == 0 )
{
if( piLen )
*piLen = 5;
return TRUE;
}
else if( strlen( szArg ) >= 2 &&
szArg[ 0 ] == '/' &&
szArg[ 1 ] == '/' )
{
if( piLen )
*piLen = 2;
return TRUE;
}
return FALSE;
}
| cmdarg.c | 118 |
STATIC CHAR * | hb_cmdargGet( const char * pszName, BOOL bRetValue )
static char * hb_cmdargGet( const char * pszName, BOOL bRetValue )
{
char * pszRetVal = NULL;
char * pszEnvVar;
int i;
int iPrefixLen;
HB_TRACE(HB_TR_DEBUG, ("hb_cmdargGet(%s, %d)", pszName, (int) bRetValue));
/* Check the command line first */
for( i = 1; i < s_argc; i++ )
{
if( hb_cmdargIsInternal( s_argv[ i ], &iPrefixLen ) &&
hb_strnicmp( s_argv[ i ] + iPrefixLen, pszName, strlen( pszName ) ) == 0 )
{
if( bRetValue )
{
char * pszPos = s_argv[ i ] + iPrefixLen + strlen( pszName );
if( *pszPos == ':' )
pszPos++;
return hb_strdup( pszPos );
}
else
return "";
}
}
/* Check the environment variable */
pszEnvVar = hb_getenv( "HARBOUR" );
if( !pszEnvVar || pszEnvVar[ 0 ] == '\0' )
{
if( pszEnvVar )
hb_xfree( ( void * ) pszEnvVar );
pszEnvVar = hb_getenv( "CLIPPER" );
}
if( pszEnvVar && pszEnvVar[ 0 ] != '\0' )
{
char * pszNext = pszEnvVar;
/* Step through all envvar switches. */
/* NOTE: CA-Cl*pper doesn't need the switches to be separated by any
chars at all, Harbour is more strict/standard in this respect,
it requires the switches to be separated. */
i = strlen( pszName );
while( *pszNext )
{
static const char * szSeparator = " ;,\t";
char * pszEnd;
/* Skip the separators */
while( *pszNext && strchr( szSeparator, *pszNext ) )
pszNext++;
/* The // is optional in the envvar */
if( hb_cmdargIsInternal( pszNext, &iPrefixLen ) )
pszNext += iPrefixLen;
pszEnd = pszNext;
/* Search for the end of this switch */
while( *pszEnd && strchr( szSeparator, *pszEnd ) == NULL )
pszEnd++;
/* Check the switch */
if( hb_strnicmp( pszNext, pszName, i ) == 0 )
{
if( bRetValue )
{
ULONG ulLen;
pszNext += i;
/* Skip value separator colon. */
if( *pszNext == ':' )
pszNext++;
ulLen = pszEnd > pszNext ? pszEnd - pszNext : 0;
pszRetVal = ( char * ) hb_xgrab( ulLen + 1 );
strncpy( pszRetVal, pszNext, ulLen );
pszRetVal[ ulLen ] = '\0';
}
else
pszRetVal = "";
break;
}
/* Step to the next switch */
pszNext = pszEnd;
}
}
if( pszEnvVar )
hb_xfree( ( void * ) pszEnvVar );
return pszRetVal;
}
| cmdarg.c | 146 |
BOOL | hb_cmdargCheck( const char * pszName )
BOOL hb_cmdargCheck( const char * pszName )
{
return hb_cmdargGet( pszName, FALSE ) != NULL;
}
| cmdarg.c | 248 |
CHAR * | hb_cmdargString( const char * pszName )
char * hb_cmdargString( const char * pszName )
{
return hb_cmdargGet( pszName, TRUE );
}
| cmdarg.c | 255 |
INT | hb_cmdargNum( const char * pszName )
int hb_cmdargNum( const char * pszName )
{
char * pszValue;
HB_TRACE(HB_TR_DEBUG, ("hb_cmdargNum(%s)", pszName));
pszValue = hb_cmdargGet( pszName, TRUE );
if( pszValue )
{
int iValue = atoi( pszValue );
hb_xfree( pszValue );
return iValue;
}
else
return -1;
}
| cmdarg.c | 260 |
HB_FUNC | HB_ARGCHECK(void)
HB_FUNC( HB_ARGCHECK )
{
hb_retl( ISCHAR( 1 ) ? hb_cmdargCheck( hb_parc( 1 ) ) : FALSE );
}
| cmdarg.c | 281 |
HB_FUNC | HB_ARGSTRING(void)
HB_FUNC( HB_ARGSTRING )
{
if( ISCHAR( 1 ) )
{
char * pszValue = hb_cmdargString( hb_parc( 1 ) );
if( pszValue )
{
hb_retc( pszValue );
hb_xfree( pszValue );
}
}
else
hb_retc( NULL );
}
| cmdarg.c | 288 |
HB_FUNC | HB_ARGC(void)
HB_FUNC( HB_ARGC )
{
hb_retni( s_argc - 1 );
}
| cmdarg.c | 307 |
HB_FUNC | HB_ARGV(void)
HB_FUNC( HB_ARGV )
{
if( ISNUM( 1 ) )
{
int argc = hb_parni( 1 );
hb_retc( ( argc >= 0 && argc < s_argc ) ? s_argv[ argc ] : NULL );
}
else
hb_retc( NULL );
}
| cmdarg.c | 316 |
ULONG | hb_cmdargProcessVM( int *pCancelKey, int *pCancelKeyEx )
ULONG hb_cmdargProcessVM( int *pCancelKey, int *pCancelKeyEx )
{
char * cFlags;
ULONG ulFlags = HB_VMFLAG_HARBOUR;
if( hb_cmdargCheck( "INFO" ) )
{
{
char * pszVersion = hb_verHarbour();
hb_conOutErr( pszVersion, 0 );
hb_conOutErr( hb_conNewLine(), 0 );
hb_xfree( pszVersion );
}
{
char * pszVersion = hb_verPlatform();
hb_conOutErr( pszVersion, 0 );
hb_conOutErr( hb_conNewLine(), 0 );
hb_xfree( pszVersion );
}
{
char buffer[ 128 ];
/* snprintf( buffer, sizeof( buffer ), "DS avail=%luKB OS avail=%luKB EMM avail=%luKB", hb_xquery( HB_MEM_BLOCK ), hb_xquery( HB_MEM_VM ), hb_xquery( HB_MEM_EMS ) ); */
snprintf( buffer, sizeof( buffer ), "DS avail=%luKB OS avail=%luKB EMM avail=%luKB MemStat:%s", hb_xquery( HB_MEM_BLOCK ), hb_xquery( HB_MEM_VM ), hb_xquery( HB_MEM_EMS ), hb_xquery( HB_MEM_USEDMAX ) ? "On" : "Off" );
hb_conOutErr( buffer, 0 );
hb_conOutErr( hb_conNewLine(), 0 );
}
}
if( hb_cmdargCheck( "BUILD" ) )
hb_verBuildInfo();
if( ( cFlags = hb_cmdargString( "FLAGS" ) ) != NULL )
{
int i = 0;
while( cFlags[ i ] )
{
switch( cFlags[ i++ ] )
{
case 'c':
/* clear all flags - minimal set of features */
ulFlags = 0;
break;
case 'h':
/* default Harbour mode */
ulFlags |= HB_VMFLAG_HARBOUR;
break;
/*
case 'x':
ulFlags |= HB_VMFLAG_XBASE;
break;
case 'r':
ulFlags |= HB_VMFLAG_RT_MACRO;
break;
*/
case 's':
ulFlags |= HB_VMFLAG_ARRSTR;
break;
}
}
hb_xfree( cFlags );
}
if( ( cFlags = hb_cmdargString( "CANCEL" ) ) != NULL )
{
int iVal = atoi( cFlags );
if( iVal )
*pCancelKey = iVal;
hb_xfree( cFlags );
}
if( ( cFlags = hb_cmdargString( "CANCELEX" ) ) != NULL )
{
int iVal = atoi( cFlags );
if( iVal )
*pCancelKeyEx = iVal;
hb_xfree( cFlags );
}
return ulFlags;
}
| cmdarg.c | 328 |
INT | hb_verSvnID( void )
int hb_verSvnID( void )
{
return HB_VER_SVNID;
}
| cmdarg.c | 414 |
CONST CHAR * | hb_verSvnChangeLogID( void )
const char * hb_verSvnChangeLogID( void )
{
return HB_VER_CHLID;
}
| cmdarg.c | 420 |
CONST CHAR * | hb_verSvnLastEntry( void )
const char * hb_verSvnLastEntry( void )
{
return HB_VER_LENTRY;
}
| cmdarg.c | 426 |
CONST CHAR * | hb_verFlagsC( void )
const char * hb_verFlagsC( void )
{
#ifdef HB_VER_C_USR
return HB_VER_C_USR;
#else
return "";
#endif
}
| cmdarg.c | 432 |
CONST CHAR * | hb_verFlagsL( void )
const char * hb_verFlagsL( void )
{
#ifdef HB_VER_L_USR
return HB_VER_L_USR;
#else
return "";
#endif
}
| cmdarg.c | 442 |
CONST CHAR * | hb_verFlagsPRG( void )
const char * hb_verFlagsPRG( void )
{
#ifdef HB_VER_PRG_USR
return HB_VER_PRG_USR;
#else
return "";
#endif
}
| cmdarg.c | 452 |
codebloc.c |
Type | Function | Source | Line |
STATIC HB_GARBAGE_FUNC( | hb_codeblockDeleteGarbage )
static HB_GARBAGE_FUNC( hb_codeblockDeleteGarbage )
{
HB_CODEBLOCK_PTR pCBlock = ( HB_CODEBLOCK_PTR ) Cargo;
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockDeleteGarbage(%p)", Cargo));
/* free space allocated for pcodes - if it was a macro-compiled codeblock
*/
if( pCBlock->pCode && pCBlock->dynBuffer )
{
pCBlock->dynBuffer = FALSE;
hb_xfree( pCBlock->pCode );
}
pCBlock->pCode = ( BYTE * ) s_pCode;
/* free space allocated for local variables
*/
if( pCBlock->pLocals )
{
PHB_ITEM pLocals = pCBlock->pLocals;
USHORT uiLocals = pCBlock->uiLocals;
/* clear pCBlock->pLocals to avoid infinit loop in cross
* referenced items
*/
pCBlock->pLocals = NULL;
pCBlock->uiLocals = 0;
if( hb_xRefDec( pLocals ) )
{
while( uiLocals )
hb_memvarValueDecRef( pLocals[ uiLocals-- ].item.asMemvar.value );
hb_xfree( pLocals );
}
}
}
| codebloc.c | 68 |
HB_CODEBLOCK_PTR | hb_codeblockNew( const BYTE * pBuffer, USHORT uiLocals, const BYTE * pLocalPosTable, PHB_SYMB pSymbols, ULONG ulLen )
HB_CODEBLOCK_PTR hb_codeblockNew( const BYTE * pBuffer,
USHORT uiLocals,
const BYTE * pLocalPosTable,
PHB_SYMB pSymbols,
ULONG ulLen )
{
HB_CODEBLOCK_PTR pCBlock;
PHB_ITEM pLocals;
BYTE * pCode;
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockNew(%p, %hu, %p, %p, %lu)", pBuffer, uiLocals, pLocalPosTable, pSymbols, ulLen));
/*
* allocate memory for code block body and detach items hb_gcAlloc()
* to be safe for automatic GC activation in hb_xgrab() without
* calling hb_gcLock()/hb_gcUnlock(). [druzus]
*/
if( ulLen )
{
/*
* The codeblock pcode is stored in dynamically allocated memory that
* can be deallocated after creation of a codeblock. We have to duplicate
* the passed buffer
*/
pCode = ( BYTE * ) hb_xgrab( ulLen );
memcpy( pCode, pBuffer, ulLen );
}
else
{
/*
* The codeblock pcode is stored in static segment.
* The only allowed operation on a codeblock is evaluating it then
* there is no need to duplicate its pcode - just store the pointer to it
*/
pCode = ( BYTE * ) pBuffer;
}
if( uiLocals )
{
/* NOTE: if a codeblock will be created by macro compiler then
* uiLocal have to be ZERO
* uiLocal will be also ZERO if it is a nested codeblock
*/
USHORT ui = 1;
PHB_ITEM pLocal;
/* Create a table that will store the values of local variables
* accessed in a codeblock
* The element 0 is used as the counter of references to this table
* NOTE: This table can be shared by codeblocks created during
* evaluation of this codeblock
*/
pLocals = ( PHB_ITEM ) hb_xgrab( ( uiLocals + 1 ) * sizeof( HB_ITEM ) );
pLocals[ 0 ].type = HB_IT_LONG;
pLocals[ 0 ].item.asLong.value = 1;
do
{
/* Swap the current value of local variable with the reference to this
* value.
* TODO: If Harbour will support threads in the future then we need
* to implement some kind of semaphores here.
*/
int iLocal = HB_PCODE_MKUSHORT( pLocalPosTable );
pLocal = hb_stackLocalVariable( &iLocal );
pLocalPosTable += 2;
pLocal = hb_memvarDetachLocal( pLocal );
memcpy( pLocals + ui, pLocal, sizeof( HB_ITEM ) );
/* Increment the reference counter so this value will not be
* released if other codeblock will be deleted
*/
hb_memvarValueIncRef( pLocal->item.asMemvar.value );
}
while( ++ui <= uiLocals );
}
else
{
/* Check if this codeblock is created during evaluation of another
* codeblock - all inner codeblocks use the local variables table
* created during creation of the outermost codeblock
*/
PHB_ITEM pLocal;
pLocal = hb_stackSelfItem();
if( HB_IS_BLOCK( pLocal ) )
{
HB_CODEBLOCK_PTR pOwner = pLocal->item.asBlock.value;
uiLocals = pOwner->uiLocals;
pLocals = pOwner->pLocals;
if( pLocals )
hb_xRefInc( pLocals );
}
else
pLocals = NULL;
}
pCBlock = ( HB_CODEBLOCK_PTR ) hb_gcAlloc( sizeof( HB_CODEBLOCK ), hb_codeblockDeleteGarbage );
pCBlock->pCode = pCode;
pCBlock->dynBuffer = ulLen != 0;
pCBlock->pDefSymb = hb_stackBaseItem()->item.asSymbol.value;
pCBlock->pSymbols = pSymbols;
pCBlock->lStatics = hb_stackGetStaticsBase();
pCBlock->uiLocals = uiLocals;
pCBlock->pLocals = pLocals;
HB_TRACE(HB_TR_INFO, ("codeblock created %p", pCBlock));
return pCBlock;
}
| codebloc.c | 107 |
HB_CODEBLOCK_PTR | hb_codeblockMacroNew( const BYTE * pBuffer, ULONG ulLen )
HB_CODEBLOCK_PTR hb_codeblockMacroNew( const BYTE * pBuffer, ULONG ulLen )
{
HB_CODEBLOCK_PTR pCBlock;
BYTE * pCode;
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockMacroNew(%p, %lu)", pBuffer, ulLen));
/*
* The codeblock pcode is stored in dynamically allocated memory that
* can be deallocated after creation of a codeblock. We have to duplicate
* the passed buffer
*/
/*
* allocate memory for code block body and detach items hb_gcAlloc()
* to be safe for automatic GC activation in hb_xgrab() without
* calling hb_gcLock()/hb_gcUnlock(). [druzus]
*/
pCode = ( BYTE * ) hb_xgrab( ulLen );
memcpy( pCode, pBuffer, ulLen );
pCBlock = ( HB_CODEBLOCK_PTR ) hb_gcAlloc( sizeof( HB_CODEBLOCK ), hb_codeblockDeleteGarbage );
/* Store the number of referenced local variables */
pCBlock->pCode = pCode;
pCBlock->dynBuffer = TRUE;
pCBlock->pDefSymb = hb_stackBaseItem()->item.asSymbol.value;
pCBlock->pSymbols = NULL; /* macro-compiled codeblock cannot acces a local symbol table */
pCBlock->lStatics = hb_stackGetStaticsBase();
pCBlock->uiLocals = 0;
pCBlock->pLocals = NULL;
HB_TRACE(HB_TR_INFO, ("codeblock created %p", pCBlock));
return pCBlock;
}
| codebloc.c | 231 |
VOID | hb_codeblockEvaluate( HB_ITEM_PTR pItem )
void hb_codeblockEvaluate( HB_ITEM_PTR pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockEvaluate(%p)", pItem));
hb_stackSetStaticsBase( pItem->item.asBlock.value->lStatics );
hb_vmExecute( pItem->item.asBlock.value->pCode, pItem->item.asBlock.value->pSymbols );
}
| codebloc.c | 266 |
PHB_ITEM | hb_codeblockGetVar( PHB_ITEM pItem, LONG iItemPos )
PHB_ITEM hb_codeblockGetVar( PHB_ITEM pItem, LONG iItemPos )
{
HB_CODEBLOCK_PTR pCBlock = pItem->item.asBlock.value;
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockGetVar(%p, %ld)", pItem, iItemPos));
/* local variables accessed in a codeblock are always stored as reference */
return hb_itemUnRef( pCBlock->pLocals - iItemPos );
}
| codebloc.c | 280 |
PHB_ITEM | hb_codeblockGetRef( HB_CODEBLOCK_PTR pCBlock, LONG iItemPos )
PHB_ITEM hb_codeblockGetRef( HB_CODEBLOCK_PTR pCBlock, LONG iItemPos )
{
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockGetRef(%p, %ld)", pCBlock, iItemPos));
return pCBlock->pLocals - iItemPos;
}
| codebloc.c | 292 |
HB_EXPORT VOID * | hb_codeblockId( PHB_ITEM pItem )
HB_EXPORT void * hb_codeblockId( PHB_ITEM pItem )
{
if( HB_IS_BLOCK( pItem ) )
return ( void * ) pItem->item.asBlock.value;
else
return NULL;
}
| codebloc.c | 301 |
debug.c |
Type | Function | Source | Line |
STATIC VOID | AddToArray( PHB_ITEM pItem, PHB_ITEM pReturn, ULONG ulPos )
static void AddToArray( PHB_ITEM pItem, PHB_ITEM pReturn, ULONG ulPos )
{
HB_TRACE(HB_TR_DEBUG, ("AddToArray(%p, %p, %lu)", pItem, pReturn, ulPos));
if( HB_IS_SYMBOL( pItem ) )
{ /* Symbol is pushed as text */
PHB_ITEM pArrayItem = hb_arrayGetItemPtr( pReturn, ulPos );
if( pArrayItem )
{
ULONG ulLen = strlen( pItem->item.asSymbol.value->szName ) + 2;
char * szBuff = ( char * ) hb_xgrab( ulLen + 1 );
snprintf( szBuff, ulLen + 1, "[%s]", pItem->item.asSymbol.value->szName );
hb_itemPutCLPtr( pArrayItem, szBuff, ulLen );
}
}
else /* Normal types */
hb_itemArrayPut( pReturn, ulPos, pItem );
}
| debug.c | 60 |
HB_FUNC | HB_DBG_VMSTKGCOUNT(void)
HB_FUNC( HB_DBG_VMSTKGCOUNT )
{
hb_retnl( hb_stackTopOffset() );
}
| debug.c | 85 |
HB_FUNC | HB_DBG_VMSTKGLIST(void)
HB_FUNC( HB_DBG_VMSTKGLIST )
{
PHB_ITEM pReturn;
ULONG ulLen = hb_stackTopOffset();
ULONG ulPos;
pReturn = hb_itemArrayNew( ulLen ); /* Create a transfer array */
for( ulPos = 0; ulPos < ulLen; ++ulPos )
{
AddToArray( hb_stackItem( ulPos ), pReturn, ulPos + 1 );
}
hb_itemReturnRelease( pReturn );
}
| debug.c | 94 |
STATIC LONG | hb_stackLen( int iLevel )
static LONG hb_stackLen( int iLevel )
{
LONG lBaseOffset, lPrevOffset, lLen;
HB_TRACE(HB_TR_DEBUG, ("hb_stackLen()"));
lBaseOffset = hb_stackBaseOffset();
while( --iLevel > 0 && lBaseOffset > 1 )
lBaseOffset = hb_stackItem( lBaseOffset - 1 )->item.asSymbol.stackstate->lBaseItem + 1;
if( lBaseOffset > 1 )
{
lPrevOffset = hb_stackItem( lBaseOffset - 1 )->item.asSymbol.stackstate->lBaseItem;
lLen = lBaseOffset - lPrevOffset - 3;
}
else
lLen = 0;
return lLen;
}
| debug.c | 113 |
HB_FUNC | HB_DBG_VMSTKLCOUNT(void)
HB_FUNC( HB_DBG_VMSTKLCOUNT )
{
hb_retnl( hb_stackLen( hb_parni( 1 ) + 1 ) );
}
| debug.c | 138 |
HB_FUNC | HB_DBG_VMSTKLLIST(void)
HB_FUNC( HB_DBG_VMSTKLLIST )
{
PHB_ITEM pReturn;
ULONG ulLen, ul;
LONG lBaseOffset, lPrevOffset;
lBaseOffset = hb_stackBaseOffset();
lPrevOffset = hb_stackItem( lBaseOffset - 1 )->item.asSymbol.stackstate->lBaseItem;
ulLen = lBaseOffset - lPrevOffset - 3;
pReturn = hb_itemArrayNew( ulLen ); /* Create a transfer array */
for( ul = 0; ul < ulLen; ++ul )
AddToArray( hb_stackItem( lPrevOffset + ul ), pReturn, ul + 1 );
hb_itemReturnRelease( pReturn );
}
| debug.c | 147 |
HB_FUNC | HB_DBG_VMPARLLIST(void)
/* TODO : put bLocals / bParams */
/* somewhere for declared parameters */
/* and locals */
HB_FUNC( HB_DBG_VMPARLLIST )
{
hb_itemReturnRelease( hb_arrayFromParams( hb_parni( 1 ) + 1 ) );
}
| debug.c | 175 |
HB_EXPORT PHB_ITEM | hb_dbg_vmVarLGet( int iLevel, int iLocal )
HB_EXPORT PHB_ITEM hb_dbg_vmVarLGet( int iLevel, int iLocal )
{
PHB_ITEM pLocal = NULL;
LONG lBaseOffset;
lBaseOffset = hb_stackBaseOffset();
while( iLevel-- > 0 && lBaseOffset > 1 )
lBaseOffset = hb_stackItem( lBaseOffset - 1 )->item.asSymbol.stackstate->lBaseItem + 1;
if( iLevel < 0 )
{
if( iLocal > SHRT_MAX )
{
iLocal -= USHRT_MAX;
iLocal--;
}
if( iLocal >= 0 )
{
PHB_ITEM pBase = hb_stackItem( lBaseOffset - 1 );
if( pBase->item.asSymbol.paramcnt > pBase->item.asSymbol.paramdeclcnt &&
iLocal > pBase->item.asSymbol.paramdeclcnt )
iLocal += pBase->item.asSymbol.paramcnt - pBase->item.asSymbol.paramdeclcnt;
pLocal = hb_stackItem( lBaseOffset + iLocal );
}
else
pLocal = hb_codeblockGetRef( hb_stackItem( lBaseOffset )->item.asBlock.value, iLocal );
if( HB_IS_BYREF( pLocal ) )
pLocal = hb_itemUnRef( pLocal );
}
return pLocal;
}
| debug.c | 187 |
HB_FUNC | HB_DBG_VMVARLGET(void)
HB_FUNC( HB_DBG_VMVARLGET )
{
int iLevel = hb_parni( 1 ) + 1;
int iLocal = hb_parni( 2 );
PHB_ITEM pLocal = hb_dbg_vmVarLGet( iLevel, iLocal );
if( pLocal )
hb_itemReturn( pLocal );
else
hb_errRT_BASE( EG_ARG, 6005, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| debug.c | 224 |
HB_FUNC | HB_DBG_VMVARLSET(void)
HB_FUNC( HB_DBG_VMVARLSET )
{
int iLevel = hb_parni( 1 ) + 1;
int iLocal = hb_parni( 2 );
LONG lBaseOffset;
PHB_ITEM pLocal;
lBaseOffset = hb_stackBaseOffset();
while( iLevel-- > 0 && lBaseOffset > 1 )
lBaseOffset = hb_stackItem( lBaseOffset - 1 )->item.asSymbol.stackstate->lBaseItem + 1;
if( iLevel < 0 )
{
if( iLocal > SHRT_MAX )
{
iLocal -= USHRT_MAX;
iLocal--;
}
if( iLocal >= 0 )
{
PHB_ITEM pBase = hb_stackItem( lBaseOffset - 1 );
if( pBase->item.asSymbol.paramcnt > pBase->item.asSymbol.paramdeclcnt &&
iLocal > pBase->item.asSymbol.paramdeclcnt )
iLocal += pBase->item.asSymbol.paramcnt - pBase->item.asSymbol.paramdeclcnt;
pLocal = hb_stackItem( lBaseOffset + iLocal );
}
else
pLocal = hb_codeblockGetRef( hb_stackItem( lBaseOffset )->item.asBlock.value, iLocal );
hb_itemCopyToRef( pLocal, hb_stackItemFromBase( 3 ) );
}
}
| debug.c | 236 |
HB_FUNC | __VMSTKLCOUNT(void)
HB_FUNC( __VMSTKLCOUNT )
{
HB_FUNC_EXEC( HB_DBG_VMSTKLCOUNT );
}
| debug.c | 272 |
HB_FUNC | __VMPARLLIST(void)
HB_FUNC( __VMPARLLIST )
{
HB_FUNC_EXEC( HB_DBG_VMPARLLIST );
}
| debug.c | 277 |
HB_FUNC | __VMSTKLLIST(void)
HB_FUNC( __VMSTKLLIST )
{
HB_FUNC_EXEC( HB_DBG_VMSTKLLIST );
}
| debug.c | 282 |
HB_FUNC | __VMVARLGET(void)
HB_FUNC( __VMVARLGET )
{
HB_FUNC_EXEC( HB_DBG_VMVARLGET );
}
| debug.c | 287 |
HB_FUNC | __VMVARLSET(void)
HB_FUNC( __VMVARLSET )
{
HB_FUNC_EXEC( HB_DBG_VMVARLSET );
}
| debug.c | 292 |
HB_FUNC | __VMSTKGLIST(void)
HB_FUNC( __VMSTKGLIST )
{
HB_FUNC_EXEC( HB_DBG_VMSTKGLIST );
}
| debug.c | 297 |
HB_FUNC | __VMSTKGCOUNT(void)
HB_FUNC( __VMSTKGCOUNT )
{
HB_FUNC_EXEC( HB_DBG_VMSTKGCOUNT );
}
| debug.c | 302 |
dynlibhb.c |
Type | Function | Source | Line |
STATIC HB_GARBAGE_FUNC( | hb_libRelease )
static HB_GARBAGE_FUNC( hb_libRelease )
{
/* do nothing */
HB_SYMBOL_UNUSED( Cargo );
}
| dynlibhb.c | 70 |
STATIC VOID * | hb_parlib( int iParam )
static void * hb_parlib( int iParam )
{
void ** pDynLibPtr = ( void ** ) hb_parptrGC( hb_libRelease, iParam );
return pDynLibPtr ? * pDynLibPtr : NULL;
}
| dynlibhb.c | 78 |
HB_FUNC | HB_LIBLOAD(void)
HB_FUNC( HB_LIBLOAD )
{
void * hDynLib = NULL;
#if defined(HB_OS_WIN_32)
if( hb_parclen( 1 ) > 0 )
{
int argc = hb_pcount() - 1, i;
char **argv = NULL;
if( argc > 0 )
{
argv = ( char** ) hb_xgrab( sizeof( char* ) * argc );
for( i = 0; i < argc; ++i )
{
argv[i] = hb_parcx( i + 2 );
}
}
/* use stack address as first level marker */
hb_vmBeginSymbolGroup( ( void * ) hb_stackId(), TRUE );
hDynLib = ( void * ) LoadLibraryA( hb_parc( 1 ) );
/* set real marker */
hb_vmInitSymbolGroup( hDynLib, argc, argv );
if( argv )
{
hb_xfree( argv );
}
}
#elif defined(HB_OS_LINUX) && !defined(__WATCOMC__)
if( hb_parclen( 1 ) > 0 )
{
int argc = hb_pcount() - 1, i;
char **argv = NULL;
if( argc > 0 )
{
argv = ( char** ) hb_xgrab( sizeof( char* ) * argc );
for( i = 0; i < argc; ++i )
{
argv[i] = hb_parcx( i + 2 );
}
}
/* use stack address as first level marker */
hb_vmBeginSymbolGroup( ( void * ) hb_stackId(), TRUE );
hDynLib = ( void * ) dlopen( hb_parc( 1 ), RTLD_LAZY | RTLD_GLOBAL );
/* set real marker */
hb_vmInitSymbolGroup( hDynLib, argc, argv );
if( argv )
{
hb_xfree( argv );
}
}
#endif
if( hDynLib )
{
void ** pLibPtr = ( void ** ) hb_gcAlloc( sizeof( void * ), hb_libRelease );
* pLibPtr = hDynLib;
hb_retptrGC( pLibPtr );
}
else
hb_ret();
}
| dynlibhb.c | 86 |
HB_FUNC | HB_LIBFREE(void)
HB_FUNC( HB_LIBFREE )
{
#if defined(HB_OS_WIN_32)
void * hDynLib = hb_parlib( 1 );
if( hDynLib )
{
hb_vmExitSymbolGroup( hDynLib );
hb_retl( FreeLibrary( ( HMODULE ) hDynLib ) );
}
else
#elif defined(HB_OS_LINUX) && !defined(__WATCOMC__)
void * hDynLib = hb_parlib( 1 );
if( hDynLib )
{
hb_vmExitSymbolGroup( hDynLib );
hb_retl( dlclose( hDynLib ) == 0 );
}
else
#endif
{
hb_retl( FALSE );
}
}
| dynlibhb.c | 152 |
HB_FUNC | HB_LIBERROR(void)
HB_FUNC( HB_LIBERROR )
{
#if defined(HB_OS_LINUX) && !defined(__WATCOMC__)
hb_retc( dlerror() );
#else
hb_retc( NULL );
#endif
}
| dynlibhb.c | 178 |
HB_FUNC | HB_LIBDO(void)
HB_FUNC( HB_LIBDO )
{
if( hb_parclen( 1 ) > 0 )
{
PHB_DYNS pDynSym = hb_dynsymFindName( hb_parc( 1 ) );
if( pDynSym )
{
USHORT uiPCount = hb_pcount();
USHORT uiParam;
hb_vmPushSymbol( pDynSym->pSymbol );
hb_vmPushNil();
/* same logic here as from HB_FUNC( EVAL ) */
for( uiParam = 2; uiParam <= uiPCount; uiParam++ )
{
hb_vmPush( hb_stackItemFromBase( uiParam ) );
}
hb_vmDo( uiPCount - 1 );
}
}
}
| dynlibhb.c | 191 |
dynsym.c |
Type | Function | Source | Line |
VOID | hb_dynsymLog( void )
void hb_dynsymLog( void )
{
USHORT uiPos;
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymLog()"));
for( uiPos = 0; uiPos < s_uiDynSymbols; uiPos++ ) /* For all dynamic symbols */
printf( "%i %s\n", uiPos + 1, s_pDynItems[ uiPos ].pDynSym->pSymbol->szName );
}
| dynsym.c | 83 |
HB_EXPORT PHB_SYMB | hb_symbolNew( const char * szName )
HB_EXPORT PHB_SYMB hb_symbolNew( const char * szName ) /* Create a new symbol */
{
PHB_SYM_HOLDER pHolder;
int iLen;
HB_TRACE(HB_TR_DEBUG, ("hb_symbolNew(%s)", szName));
iLen = strlen( szName );
pHolder = ( PHB_SYM_HOLDER ) hb_xgrab( sizeof( HB_SYM_HOLDER ) + iLen );
memcpy( pHolder->szName, szName, iLen + 1 );
pHolder->pNext = s_pAllocSyms;
s_pAllocSyms = pHolder;
pHolder->symbol.szName = pHolder->szName;
pHolder->symbol.scope.value = 0;
pHolder->symbol.value.pFunPtr = NULL;
pHolder->symbol.pDynSym = NULL;
return &pHolder->symbol;
}
| dynsym.c | 93 |
HB_EXPORT PHB_DYNS | hb_dynsymNew( PHB_SYMB pSymbol )
HB_EXPORT PHB_DYNS hb_dynsymNew( PHB_SYMB pSymbol ) /* creates a new dynamic symbol */
{
PHB_DYNS pDynSym;
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymNew(%p)", pSymbol));
pDynSym = hb_dynsymFind( pSymbol->szName ); /* Find position */
if( pDynSym ) /* If name exists */
{
if( ( pDynSym->pSymbol->scope.value &
pSymbol->scope.value & HB_FS_LOCAL ) != 0 &&
pDynSym->pSymbol != pSymbol )
{
/* Someone is using linker which allows to create binaries
* with multiple function definitions. It's a big chance that
* wrong binaries are created in such case, f.e both functions
* linked and not all references updated. Anyhow now we will
* have to guess which symbol is the real local one [druzus]
*/
/* Let's check if linker updated function address so both symbols
* refer to the same function
*/
if( pDynSym->pSymbol->value.pFunPtr == pSymbol->value.pFunPtr )
{
/* The addresses have been updated, f.e. in such way works GCC
* in Linux (but not MinGW and DJGPP) if user will allow to create
* binaries with multiple symbols by
* -Wl,--allow-multiple-definition
* when whole module cannot be cleanly replaced.
* OpenWatcom for Linux, DOS and Windows (I haven't tested OS2
* version), POCC and XCC (with /FORCE:MULTIPLE) also update
* addresses in such case.
*
* We are guessing that symbols are registered in reverted order
* so we remove the HB_FS_LOCAL flag from previously registered
* symbol but some linkers may use different order so it does
* not have to be true in all cases
*/
pDynSym->pSymbol->scope.value &= ~HB_FS_LOCAL;
}
else
{
/* We have multiple symbol with the same name which refer
* to different public functions inside this single binary
* Let's check if this symbol is loaded from dynamic library
* (.so, .dll, .dyn, ...) or .hrb file
*/
if( pSymbol->scope.value & HB_FS_PCODEFUNC )
{
/* It's dynamic module so we are guessing that HVM
* intentionally not updated function address allowing
* multiple functions, f.e. programmer asked about keeping
* local references using HB_LIBLOAD()/__HBRLOAD() parameter.
* In such case update pDynSym address in the new symbol but
* do not register it as the main one
*/
pSymbol->pDynSym = pDynSym; /* place a pointer to DynSym */
return pDynSym; /* Return pointer to DynSym */
}
/* The multiple symbols comes from single binaries - we have to
* decide what to do with them. We can leave it as is or we can
* try to overload one symbol so both will point to the same
* function. For .prg code such overloading will work but not
* for C code which makes sth like: HB_FUNC_EXEC( funcname )
* In such case we cannot do anything - we cannot even detect
* such situation. In some cases even linker cannot detect it
* because C compiler can make autoinlining or some bindings
* which are not visible for linker
*/
/* Let's try to overload one of the functions. Simple:
* pDynSym->pSymbol->value.pFunPtr = pSymbol->value.pFunPtr;
* is not good idea because it's possible that this symbol will
* be overloaded yet another time after preprocessing rest of
* symbols so we will use HB_FS_DEFERRED flag which is updated
* dynamically in hb_vmSend()/hb_vmDo() functions
*/
#define HB_OVERLOAD_MULTIPLE_FUNC
#if defined( HB_OVERLOAD_MULTIPLE_FUNC )
/* In such way works MinGW, DJGPP, BCC */
#if defined( __GNUC__ ) && !defined( __DJGPP__ )
/* MinGW (like most of other GCC ports) uses reverted order for
* initialization functions
*/
pDynSym->pSymbol->scope.value &= ~HB_FS_LOCAL;
pDynSym->pSymbol->scope.value |= HB_FS_DEFERRED;
#else
/* BCC, DJGPP, ... */
pSymbol->scope.value &= ~HB_FS_LOCAL;
pSymbol->scope.value |= HB_FS_DEFERRED;
#endif
#endif
}
}
if( ( !pDynSym->pSymbol->value.pFunPtr && pSymbol->value.pFunPtr ) ||
( pSymbol->scope.value & HB_FS_LOCAL ) != 0 )
{
pDynSym->pSymbol = pSymbol;
#ifndef HB_NO_PROFILER
pDynSym->ulCalls = 0; /* profiler support */
pDynSym->ulTime = 0; /* profiler support */
pDynSym->ulRecurse = 0; /* profiler support */
#endif
}
pSymbol->pDynSym = pDynSym; /* place a pointer to DynSym */
return pDynSym; /* Return pointer to DynSym */
}
if( s_uiDynSymbols == 0 ) /* Do we have any symbols ? */
{
pDynSym = s_pDynItems[ 0 ].pDynSym; /* Point to first symbol */
/* *<1>* Remember we already got this one */
s_uiDynSymbols++;
}
else
{ /* We want more symbols ! */
if( ++s_uiDynSymbols == 0 )
hb_errInternal( 6004, "Internal error: size of dynamic symbol table exceed", NULL, NULL );
s_pDynItems = ( PDYNHB_ITEM ) hb_xrealloc( s_pDynItems, s_uiDynSymbols * sizeof( DYNHB_ITEM ) );
memmove( &s_pDynItems[ s_uiClosestDynSym + 1 ],
&s_pDynItems[ s_uiClosestDynSym ],
sizeof( DYNHB_ITEM ) * ( s_uiDynSymbols - s_uiClosestDynSym - 1 ) );
pDynSym = ( PHB_DYNS ) hb_xgrab( sizeof( HB_DYNS ) );
s_pDynItems[ s_uiClosestDynSym ].pDynSym = pDynSym; /* Enter DynSym */
}
pDynSym->pSymbol = pSymbol;
pDynSym->hMemvar = 0;
pDynSym->uiArea = 0;
pDynSym->uiSymNum = s_uiDynSymbols;
#ifndef HB_NO_PROFILER
pDynSym->ulCalls = 0; /* profiler support */
pDynSym->ulTime = 0; /* profiler support */
pDynSym->ulRecurse = 0; /* profiler support */
#endif
pSymbol->pDynSym = pDynSym; /* place a pointer to DynSym */
return pDynSym;
}
| dynsym.c | 114 |
HB_EXPORT PHB_DYNS | hb_dynsymGetCase( const char * szName )
HB_EXPORT PHB_DYNS hb_dynsymGetCase( const char * szName ) /* finds and creates a symbol if not found */
{
PHB_DYNS pDynSym;
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymGetCase(%s)", szName));
pDynSym = hb_dynsymFind( szName );
if( ! pDynSym ) /* Does it exists ? */
pDynSym = hb_dynsymNew( hb_symbolNew( szName ) ); /* Make new symbol */
return pDynSym;
}
| dynsym.c | 259 |
HB_EXPORT PHB_DYNS | hb_dynsymGet( const char * szName )
HB_EXPORT PHB_DYNS hb_dynsymGet( const char * szName ) /* finds and creates a symbol if not found */
{
PHB_DYNS pDynSym;
char szUprName[ HB_SYMBOL_NAME_LEN + 1 ];
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymGet(%s)", szName));
/* make a copy as we may get a const string, then turn it to uppercase */
/* NOTE: This block is optimized for speed [vszakats] */
{
int iLen = HB_SYMBOL_NAME_LEN;
char * pDest = szUprName;
do
{
char cChar = *szName++;
if( cChar == 0 || cChar == ' ' || cChar == '\t' )
break;
else if( cChar >= 'a' && cChar <= 'z' )
*pDest++ = cChar - ( 'a' - 'A' );
else
*pDest++ = cChar;
}
while( --iLen );
*pDest = '\0';
}
pDynSym = hb_dynsymFind( szUprName );
if( ! pDynSym ) /* Does it exists ? */
pDynSym = hb_dynsymNew( hb_symbolNew( szUprName ) ); /* Make new symbol */
return pDynSym;
}
| dynsym.c | 272 |
HB_EXPORT PHB_DYNS | hb_dynsymFindName( const char * szName )
HB_EXPORT PHB_DYNS hb_dynsymFindName( const char * szName ) /* finds a symbol */
{
char szUprName[ HB_SYMBOL_NAME_LEN + 1 ];
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymFindName(%s)", szName));
/* make a copy as we may get a const string, then turn it to uppercase */
/* NOTE: This block is optimized for speed [vszakats] */
{
int iLen = HB_SYMBOL_NAME_LEN;
char * pDest = szUprName;
do
{
char cChar = *szName++;
if( cChar == 0 || cChar == ' ' || cChar == '\t' )
break;
else if( cChar >= 'a' && cChar <= 'z' )
*pDest++ = cChar - ( 'a' - 'A' );
else
*pDest++ = cChar;
}
while( --iLen );
*pDest = '\0';
}
return hb_dynsymFind( szUprName );
}
| dynsym.c | 306 |
HB_EXPORT PHB_DYNS | hb_dynsymFind( const char * szName )
HB_EXPORT PHB_DYNS hb_dynsymFind( const char * szName )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymFind(%s)", szName));
if( s_pDynItems == NULL )
{
s_pDynItems = ( PDYNHB_ITEM ) hb_xgrab( sizeof( DYNHB_ITEM ) ); /* Grab array */
s_pDynItems->pDynSym = ( PHB_DYNS ) hb_xgrab( sizeof( HB_DYNS ) );
/* Always grab a first symbol. Never an empty bucket. *<1>* */
memset( s_pDynItems->pDynSym, 0, sizeof( HB_DYNS ) );
}
else
{
/* Classic Tree Insert Sort Mechanism
*
* Insert Sort means the new item is entered alphabetically into
* the array. In this case s_pDynItems !
*
* 1) We start in the middle of the array.
* 2a) If the symbols are equal -> we have found the symbol !!
* Champagne ! We're done.
* b) If the symbol we are looking for ('ge') is greater than the
* middle ('po'), we start looking left.
* Only the first part of the array is going to be searched.
* Go to (1)
* c) If the symbol we are looking for ('ge') is smaller than the
* middle ('ko'), we start looking right
* Only the last part of the array is going to be searched.
* Go to (1)
*/
USHORT uiFirst = 0;
USHORT uiLast = s_uiDynSymbols;
USHORT uiMiddle = uiLast >> 1;
s_uiClosestDynSym = uiMiddle; /* Start in the middle */
while( uiFirst < uiLast )
{
int iCmp = strcmp( s_pDynItems[ uiMiddle ].pDynSym->pSymbol->szName, szName );
if( iCmp == 0 )
{
s_uiClosestDynSym = uiMiddle;
return s_pDynItems[ uiMiddle ].pDynSym;
}
else if( iCmp < 0 )
{
uiLast = uiMiddle;
s_uiClosestDynSym = uiMiddle;
}
else /* if( iCmp > 0 ) */
{
uiFirst = uiMiddle + 1;
s_uiClosestDynSym = uiFirst;
}
uiMiddle = ( uiFirst + uiLast ) >> 1;
}
}
return NULL;
}
| dynsym.c | 335 |
HB_EXPORT PHB_SYMB | hb_dynsymGetSymbol( const char * szName )
HB_EXPORT PHB_SYMB hb_dynsymGetSymbol( const char * szName )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymGetSymbol(%s)", szName));
return hb_dynsymGet( szName )->pSymbol;
}
| dynsym.c | 398 |
HB_EXPORT PHB_SYMB | hb_dynsymFindSymbol( const char * szName )
HB_EXPORT PHB_SYMB hb_dynsymFindSymbol( const char * szName )
{
PHB_DYNS pDynSym;
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymFindSymbol(%s)", szName));
pDynSym = hb_dynsymFind( szName );
return pDynSym ? pDynSym->pSymbol : NULL;
}
| dynsym.c | 405 |
HB_EXPORT PHB_SYMB | hb_dynsymSymbol( PHB_DYNS pDynSym )
HB_EXPORT PHB_SYMB hb_dynsymSymbol( PHB_DYNS pDynSym )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymSymbol(%p)", pDynSym));
return pDynSym->pSymbol;
}
| dynsym.c | 415 |
HB_EXPORT CONST CHAR * | hb_dynsymName( PHB_DYNS pDynSym )
HB_EXPORT const char * hb_dynsymName( PHB_DYNS pDynSym )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymName(%p)", pDynSym));
return pDynSym->pSymbol->szName;
}
| dynsym.c | 422 |
HB_EXPORT BOOL | hb_dynsymIsFunction( PHB_DYNS pDynSym )
HB_EXPORT BOOL hb_dynsymIsFunction( PHB_DYNS pDynSym )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymIsFunction(%p)", pDynSym));
return pDynSym->pSymbol->value.pFunPtr != NULL;
}
| dynsym.c | 429 |
HB_EXPORT HB_HANDLE | hb_dynsymMemvarHandle( PHB_DYNS pDynSym )
HB_EXPORT HB_HANDLE hb_dynsymMemvarHandle( PHB_DYNS pDynSym )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymMemvarHandle(%p)", pDynSym));
return pDynSym->hMemvar;
}
| dynsym.c | 436 |
HB_EXPORT INT | hb_dynsymAreaHandle( PHB_DYNS pDynSym )
HB_EXPORT int hb_dynsymAreaHandle( PHB_DYNS pDynSym )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymAreaHandle(%p)", pDynSym));
return pDynSym->uiArea;
}
| dynsym.c | 443 |
HB_EXPORT VOID | hb_dynsymSetAreaHandle( PHB_DYNS pDynSym, int iArea )
HB_EXPORT void hb_dynsymSetAreaHandle( PHB_DYNS pDynSym, int iArea )
{
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymSetAreaHandle(%p,%d)", pDynSym, iArea));
pDynSym->uiArea = ( USHORT ) iArea;
}
| dynsym.c | 450 |
VOID | hb_dynsymEval( PHB_DYNS_FUNC pFunction, void * Cargo )
void hb_dynsymEval( PHB_DYNS_FUNC pFunction, void * Cargo )
{
BOOL bCont = TRUE;
USHORT uiPos;
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymEval(%p, %p)", pFunction, Cargo));
for( uiPos = 0; uiPos < s_uiDynSymbols && bCont; uiPos++ )
bCont = ( pFunction )( s_pDynItems[ uiPos ].pDynSym, Cargo );
}
| dynsym.c | 457 |
VOID | hb_dynsymRelease( void )
void hb_dynsymRelease( void )
{
PHB_SYM_HOLDER pHolder;
USHORT uiPos;
HB_TRACE(HB_TR_DEBUG, ("hb_dynsymRelease()"));
for( uiPos = 0; uiPos < s_uiDynSymbols; uiPos++ )
{
hb_xfree( ( s_pDynItems + uiPos )->pDynSym );
}
hb_xfree( s_pDynItems );
s_pDynItems = NULL;
s_uiDynSymbols = 0;
while( s_pAllocSyms )
{
pHolder = s_pAllocSyms;
s_pAllocSyms = s_pAllocSyms->pNext;
hb_xfree( pHolder );
}
}
| dynsym.c | 468 |
HB_FUNC | __DYNSCOUNT(void)
HB_FUNC( __DYNSCOUNT ) /* How much symbols do we have: dsCount = __dynsymCount() */
{
hb_retnl( ( long ) s_uiDynSymbols );
}
| dynsym.c | 491 |
HB_FUNC | __DYNSGETNAME(void)
HB_FUNC( __DYNSGETNAME ) /* Get name of symbol: cSymbol = __dynsymGetName( dsIndex ) */
{
long lIndex = hb_parnl( 1 ); /* NOTE: This will return zero if the parameter is not numeric */
if( lIndex >= 1 && lIndex <= s_uiDynSymbols )
hb_retc( s_pDynItems[ lIndex - 1 ].pDynSym->pSymbol->szName );
else
hb_retc( NULL );
}
| dynsym.c | 496 |
HB_FUNC | __DYNSGETINDEX(void)
HB_FUNC( __DYNSGETINDEX ) /* Gimme index number of symbol: dsIndex = __dynsymGetIndex( cSymbol ) */
{
PHB_DYNS pDynSym;
char * szName = hb_parc( 1 );
if( szName )
pDynSym = hb_dynsymFindName( szName );
else
pDynSym = NULL;
if( pDynSym )
hb_retnl( ( long ) ( s_uiClosestDynSym + 1 ) );
else
hb_retnl( 0L );
}
HB_FUNC( __DYNSISFUN ) /* returns .t. if a symbol has a function/procedure pointer,
given its symbol index */
{
long lIndex = hb_parnl( 1 ); /* NOTE: This will return zero if the parameter is not numeric */
if( lIndex >= 1 && lIndex <= s_uiDynSymbols )
hb_retl( hb_dynsymIsFunction( s_pDynItems[ lIndex - 1 ].pDynSym ) );
else
hb_retl( FALSE );
}
HB_FUNC( __DYNSGETPRF ) /* profiler: It returns an array with a function or procedure
called and consumed times { nTimes, nTime }
, given the dynamic symbol index */
{
#ifndef HB_NO_PROFILER
long lIndex = hb_parnl( 1 ); /* NOTE: This will return zero if the parameter is not numeric */
#endif
hb_reta( 2 );
hb_stornl( 0, -1, 1 );
hb_stornl( 0, -1, 2 );
#ifndef HB_NO_PROFILER
if( lIndex >= 1 && lIndex <= s_uiDynSymbols )
{
if( hb_dynsymIsFunction( s_pDynItems[ lIndex - 1 ].pDynSym ) ) /* it is a function or procedure */
{
hb_stornl( s_pDynItems[ lIndex - 1 ].pDynSym->ulCalls, -1, 1 );
hb_stornl( s_pDynItems[ lIndex - 1 ].pDynSym->ulTime, -1, 2 );
}
}
#endif
}
| dynsym.c | 506 |
HB_FUNC | __DYNSN2PTR(void)
HB_FUNC( __DYNSN2PTR )
{
char * szName = hb_parc( 1 );
hb_retptr( szName ? hb_dynsymGet( szName ) : NULL );
}
| dynsym.c | 557 |
HB_FUNC | __DYNSN2SYM(void)
HB_FUNC( __DYNSN2SYM )
{
char * szName = hb_parc( 1 );
if( szName )
hb_itemPutSymbol( hb_stackReturnItem(), hb_dynsymGet( szName )->pSymbol );
}
| dynsym.c | 564 |
HB_FUNC | __DYNSP2NAME(void)
HB_FUNC( __DYNSP2NAME )
{
PHB_DYNS pDynSym = ( PHB_DYNS ) hb_parptr( 1 );
hb_retc( pDynSym != NULL ? pDynSym->pSymbol->szName : NULL );
}
| dynsym.c | 572 |
estack.c |
Type | Function | Source | Line |
VOID * | hb_stackId( void )
void * hb_stackId( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackId()"));
return ( void * ) &hb_stack;
}
| estack.c | 81 |
VOID | hb_stackPop( void )
void hb_stackPop( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackPop()"));
if( --hb_stack.pPos <= hb_stack.pBase )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
if( HB_IS_COMPLEX( * hb_stack.pPos ) )
hb_itemClear( * hb_stack.pPos );
}
| estack.c | 89 |
VOID | hb_stackPopReturn( void )
void hb_stackPopReturn( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackPopReturn()"));
if( HB_IS_COMPLEX( &hb_stack.Return ) )
hb_itemClear( &hb_stack.Return );
if( --hb_stack.pPos <= hb_stack.pBase )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
hb_itemRawMove( &hb_stack.Return, * hb_stack.pPos );
}
| estack.c | 101 |
VOID | hb_stackDec( void )
void hb_stackDec( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackDec()"));
if( --hb_stack.pPos <= hb_stack.pBase )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
}
| estack.c | 115 |
VOID | hb_stackDecrease( ULONG ulItems )
void hb_stackDecrease( ULONG ulItems )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackDecrease()"));
if( ( hb_stack.pPos -= ulItems ) <= hb_stack.pBase )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
}
| estack.c | 124 |
VOID | hb_stackFree( void )
void hb_stackFree( void )
{
LONG i;
HB_TRACE(HB_TR_DEBUG, ("hb_stackFree()"));
i = hb_stack.wItems - 1;
while( i >= 0 )
hb_xfree( hb_stack.pItems[ i-- ] );
hb_xfree( hb_stack.pItems );
hb_stack.pItems = hb_stack.pPos = hb_stack.pBase = NULL;
}
| estack.c | 132 |
VOID | hb_stackPush( void )
void hb_stackPush( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackPush()"));
/* enough room for another item ? */
if( ++hb_stack.pPos == hb_stack.pEnd )
hb_stackIncrease();
}
| estack.c | 146 |
HB_ITEM_PTR | hb_stackAllocItem( void )
HB_ITEM_PTR hb_stackAllocItem( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackAllocItem()"));
if( ++hb_stack.pPos == hb_stack.pEnd )
hb_stackIncrease();
return * ( hb_stack.pPos - 1 );
}
| estack.c | 156 |
VOID | hb_stackPushReturn( void )
void hb_stackPushReturn( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackPushReturn()"));
hb_itemRawMove( * hb_stack.pPos, &hb_stack.Return );
/* enough room for another item ? */
if( ++hb_stack.pPos == hb_stack.pEnd )
hb_stackIncrease();
}
| estack.c | 167 |
VOID | hb_stackIncrease( void )
void hb_stackIncrease( void )
{
LONG BaseIndex; /* index of stack base */
LONG CurrIndex; /* index of current top item */
LONG EndIndex; /* index of current top item */
HB_TRACE(HB_TR_DEBUG, ("hb_stackIncrease()"));
BaseIndex = hb_stack.pBase - hb_stack.pItems;
CurrIndex = hb_stack.pPos - hb_stack.pItems;
EndIndex = hb_stack.pEnd - hb_stack.pItems;
/* no, make more headroom: */
hb_stack.pItems = ( PHB_ITEM * ) hb_xrealloc( ( void * ) hb_stack.pItems,
sizeof( PHB_ITEM ) * ( hb_stack.wItems + STACK_EXPANDHB_ITEMS ) );
/* fix possibly modified by realloc pointers: */
hb_stack.pPos = hb_stack.pItems + CurrIndex;
hb_stack.pBase = hb_stack.pItems + BaseIndex;
hb_stack.wItems += STACK_EXPANDHB_ITEMS;
hb_stack.pEnd = hb_stack.pItems + hb_stack.wItems;
do
{
hb_stack.pItems[ EndIndex ] = ( PHB_ITEM ) hb_xgrab( sizeof( HB_ITEM ) );
hb_stack.pItems[ EndIndex ]->type = HB_IT_NIL;
}
while( ++EndIndex < hb_stack.wItems );
}
| estack.c | 178 |
VOID | hb_stackInit( void )
void hb_stackInit( void )
{
LONG i;
HB_TRACE(HB_TR_DEBUG, ("hb_stackInit()"));
memset( &hb_stack, 0, sizeof( HB_STACK ) );
hb_stack.pItems = ( PHB_ITEM * ) hb_xgrab( sizeof( PHB_ITEM ) * STACK_INITHB_ITEMS );
hb_stack.pBase = hb_stack.pItems;
hb_stack.pPos = hb_stack.pItems; /* points to the first stack item */
hb_stack.wItems = STACK_INITHB_ITEMS;
hb_stack.pEnd = hb_stack.pItems + hb_stack.wItems;
for( i = 0; i < hb_stack.wItems; ++i )
{
hb_stack.pItems[ i ] = ( PHB_ITEM ) hb_xgrab( sizeof( HB_ITEM ) );
hb_stack.pItems[ i ]->type = HB_IT_NIL;
}
hb_stack.pPos++;
hb_itemPutSymbol( * hb_stack.pItems, &s_initSymbol );
( * hb_stack.pItems )->item.asSymbol.stackstate = &hb_stack.state;
}
| estack.c | 208 |
VOID | hb_stackRemove( LONG lUntilPos )
void hb_stackRemove( LONG lUntilPos )
{
HB_ITEM_PTR * pEnd = hb_stack.pItems + lUntilPos;
while( hb_stack.pPos > pEnd )
{
--hb_stack.pPos;
if( HB_IS_COMPLEX( * hb_stack.pPos ) )
hb_itemClear( * hb_stack.pPos );
}
}
| estack.c | 233 |
HB_ITEM_PTR | hb_stackNewFrame( PHB_STACK_STATE pStack, USHORT uiParams )
HB_ITEM_PTR hb_stackNewFrame( PHB_STACK_STATE pStack, USHORT uiParams )
{
HB_ITEM_PTR * pBase, pItem;
pBase = hb_stack.pPos - uiParams - 2;
pItem = * pBase; /* procedure symbol */
if( ! HB_IS_SYMBOL( pItem ) )
{
hb_stackDispLocal();
hb_errInternal( HB_EI_VMNOTSYMBOL, NULL, "hb_vmDo()", NULL );
}
pStack->lBaseItem = hb_stack.pBase - hb_stack.pItems;
pStack->lStatics = hb_stack.lStatics;
pStack->ulPrivateBase = hb_memvarGetPrivatesBase();
pStack->uiClass = pStack->uiMethod = pStack->uiLineNo = 0;
pItem->item.asSymbol.stackstate = pStack;
pItem->item.asSymbol.paramcnt = uiParams;
/* set default value of 'paramdeclcnt' - it will be updated
* in hb_vm[V]Frame only
*/
pItem->item.asSymbol.paramdeclcnt = uiParams;
hb_stack.pBase = pBase;
return pItem;
}
| estack.c | 245 |
VOID | hb_stackOldFrame( PHB_STACK_STATE pStack )
void hb_stackOldFrame( PHB_STACK_STATE pStack )
{
if( hb_stack.pPos <= hb_stack.pBase )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
do
{
--hb_stack.pPos;
if( HB_IS_COMPLEX( * hb_stack.pPos ) )
hb_itemClear( * hb_stack.pPos );
}
while( hb_stack.pPos > hb_stack.pBase );
hb_stack.pBase = hb_stack.pItems + pStack->lBaseItem;
hb_stack.lStatics = pStack->lStatics;
hb_memvarSetPrivatesBase( pStack->ulPrivateBase );
}
| estack.c | 274 |
HB_ITEM_PTR | hb_stackItem( LONG iItemPos )
HB_ITEM_PTR hb_stackItem( LONG iItemPos )
{
if( iItemPos < 0 )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
return * ( hb_stack.pItems + iItemPos );
}
| estack.c | 293 |
HB_ITEM_PTR | hb_stackItemFromTop( int iFromTop )
HB_ITEM_PTR hb_stackItemFromTop( int iFromTop )
{
if( iFromTop >= 0 )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
return * ( hb_stack.pPos + iFromTop );
}
| estack.c | 302 |
HB_ITEM_PTR | hb_stackItemFromBase( int iFromBase )
HB_ITEM_PTR hb_stackItemFromBase( int iFromBase )
{
if( iFromBase < 0 )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
return * ( hb_stack.pBase + iFromBase + 1 );
}
| estack.c | 311 |
HB_ITEM_PTR | hb_stackLocalVariable( int *piFromBase )
HB_ITEM_PTR hb_stackLocalVariable( int *piFromBase )
{
HB_ITEM_PTR pBase = *hb_stack.pBase;
/*
if( *piFromBase <= 0 )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
*/
if( pBase->item.asSymbol.paramcnt > pBase->item.asSymbol.paramdeclcnt )
{
/* function with variable number of parameters:
* FUNCTION foo( a,b,c,...)
* LOCAL x,y,z
* number of passed parameters is bigger then number of declared
* parameters - skip additional parameters only for local variables
*/
if( *piFromBase > pBase->item.asSymbol.paramdeclcnt )
*piFromBase += pBase->item.asSymbol.paramcnt - pBase->item.asSymbol.paramdeclcnt;
}
return * ( hb_stack.pBase + *piFromBase + 1 );
}
| estack.c | 320 |
HB_ITEM_PTR | hb_stackBaseItem( void )
HB_ITEM_PTR hb_stackBaseItem( void )
{
return * hb_stack.pBase;
}
| estack.c | 343 |
HB_ITEM_PTR | hb_stackSelfItem( void )
HB_ITEM_PTR hb_stackSelfItem( void )
{
return * ( hb_stack.pBase + 1 );
}
| estack.c | 351 |
HB_ITEM_PTR | hb_stackReturnItem( void )
HB_ITEM_PTR hb_stackReturnItem( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackReturnItem()"));
return &hb_stack.Return;
}
| estack.c | 357 |
LONG | hb_stackTopOffset( void )
LONG hb_stackTopOffset( void )
{
return hb_stack.pPos - hb_stack.pItems;
}
| estack.c | 365 |
LONG | hb_stackBaseOffset( void )
LONG hb_stackBaseOffset( void )
{
return hb_stack.pBase - hb_stack.pItems + 1;
}
| estack.c | 371 |
LONG | hb_stackTotalItems( void )
LONG hb_stackTotalItems( void )
{
return hb_stack.wItems;
}
| estack.c | 377 |
CHAR * | hb_stackDateBuffer( void )
char * hb_stackDateBuffer( void )
{
return hb_stack.szDate;
}
| estack.c | 383 |
LONG | hb_stackGetStaticsBase( void )
LONG hb_stackGetStaticsBase( void )
{
return hb_stack.lStatics;
}
| estack.c | 389 |
VOID | hb_stackSetStaticsBase( LONG lBase )
void hb_stackSetStaticsBase( LONG lBase )
{
hb_stack.lStatics = lBase;
}
| estack.c | 395 |
LONG | hb_stackGetRecoverBase( void )
LONG hb_stackGetRecoverBase( void )
{
return hb_stack.lRecoverBase;
}
| estack.c | 401 |
VOID | hb_stackSetRecoverBase( LONG lBase )
void hb_stackSetRecoverBase( LONG lBase )
{
hb_stack.lRecoverBase = lBase;
}
| estack.c | 407 |
USHORT | hb_stackGetActionRequest( void )
USHORT hb_stackGetActionRequest( void )
{
return hb_stack.uiActionRequest;
}
| estack.c | 413 |
VOID | hb_stackSetActionRequest( USHORT uiAction )
void hb_stackSetActionRequest( USHORT uiAction )
{
hb_stack.uiActionRequest = uiAction;
}
| estack.c | 419 |
PHB_ITEM | hb_stackWithObjectItem( void )
PHB_ITEM hb_stackWithObjectItem( void )
{
return hb_stack.lWithObject ?
* ( hb_stack.pItems + hb_stack.lWithObject ) : NULL;
}
| estack.c | 425 |
LONG | hb_stackWithObjectOffset( void )
LONG hb_stackWithObjectOffset( void )
{
return hb_stack.lWithObject;
}
| estack.c | 432 |
VOID | hb_stackWithObjectSetOffset( LONG lOffset )
void hb_stackWithObjectSetOffset( LONG lOffset )
{
hb_stack.lWithObject = lOffset;
}
| estack.c | 438 |
PHB_ITEM ** | hb_stackItemBasePtr( void )
PHB_ITEM ** hb_stackItemBasePtr( void )
{
return &hb_stack.pItems;
}
| estack.c | 444 |
VOID | hb_stackClearMevarsBase( void )
void hb_stackClearMevarsBase( void )
{
PHB_ITEM pBase;
HB_TRACE(HB_TR_DEBUG, ("hb_stackClearMevarsBase()"));
pBase = * hb_stack.pBase;
while( pBase->item.asSymbol.stackstate->ulPrivateBase != 0 )
{
pBase->item.asSymbol.stackstate->ulPrivateBase = 0;
pBase = * ( hb_stack.pItems + pBase->item.asSymbol.stackstate->lBaseItem );
}
}
| estack.c | 449 |
INT | hb_stackCallDepth( void )
int hb_stackCallDepth( void )
{
LONG lOffset = hb_stack.pBase - hb_stack.pItems;
int iLevel = 0;
while( lOffset > 0 )
{
lOffset = ( * ( hb_stack.pItems + lOffset ) )->item.asSymbol.stackstate->lBaseItem;
++iLevel;
}
return iLevel;
}
| estack.c | 464 |
LONG | hb_stackBaseProcOffset( int iLevel )
LONG hb_stackBaseProcOffset( int iLevel )
{
LONG lOffset = hb_stack.pBase - hb_stack.pItems;
while( iLevel-- > 0 && lOffset > 0 )
lOffset = ( * ( hb_stack.pItems + lOffset ) )->item.asSymbol.stackstate->lBaseItem;
if( iLevel < 0 && ( lOffset > 0 || HB_IS_SYMBOL( * hb_stack.pItems ) ) )
return lOffset;
else
return -1;
}
| estack.c | 478 |
VOID | hb_stackBaseProcInfo( char * szProcName, USHORT * puiProcLine )
void hb_stackBaseProcInfo( char * szProcName, USHORT * puiProcLine )
{
/*
* This function is called by FM module and has to be ready for execution
* before hb_stack initialization, [druzus]
* szProcName should be at least HB_SYMBOL_NAME_LEN + 1 bytes buffer
*/
if( hb_stack.pPos > hb_stack.pBase )
{
hb_strncpy( szProcName, ( * hb_stack.pBase )->item.asSymbol.value->szName,
HB_SYMBOL_NAME_LEN );
* puiProcLine = ( * hb_stack.pBase )->item.asSymbol.stackstate->uiLineNo;
}
else
{
szProcName[ 0 ] = '\0';
* puiProcLine = 0;
}
}
| estack.c | 491 |
VOID | hb_stackDispLocal( void )
void hb_stackDispLocal( void )
{
PHB_ITEM * pBase;
HB_TRACE(HB_TR_DEBUG, ("hb_stackDispLocal()"));
printf( hb_conNewLine() );
printf( HB_I_("Virtual Machine Stack Dump at %s(%i):"),
( *hb_stack.pBase )->item.asSymbol.value->szName,
( *hb_stack.pBase )->item.asSymbol.stackstate->uiLineNo );
printf( hb_conNewLine() );
printf( "--------------------------" );
for( pBase = hb_stack.pBase; pBase <= hb_stack.pPos; pBase++ )
{
printf( hb_conNewLine() );
switch( hb_itemType( *pBase ) )
{
case HB_IT_NIL:
printf( HB_I_("NIL ") );
break;
case HB_IT_ARRAY:
if( hb_arrayIsObject( *pBase ) )
printf( HB_I_("OBJECT = %s "), hb_objGetClsName( *pBase ) );
else
printf( HB_I_("ARRAY ") );
break;
case HB_IT_BLOCK:
printf( HB_I_("BLOCK ") );
break;
case HB_IT_DATE:
{
char szDate[ 9 ];
printf( HB_I_("DATE = \"%s\" "), hb_itemGetDS( *pBase, szDate ) );
}
break;
case HB_IT_DOUBLE:
printf( HB_I_("DOUBLE = %f "), hb_itemGetND( *pBase ) );
break;
case HB_IT_LOGICAL:
printf( HB_I_("LOGICAL = %s "), hb_itemGetL( *pBase ) ? ".T." : ".F." );
break;
case HB_IT_LONG:
printf( HB_I_("LONG = %" PFHL "i ") , hb_itemGetNInt( *pBase ) );
break;
case HB_IT_INTEGER:
printf( HB_I_("INTEGER = %i "), hb_itemGetNI( *pBase ) );
break;
case HB_IT_STRING:
printf( HB_I_("STRING = \"%s\" "), hb_itemGetCPtr( *pBase ) );
break;
case HB_IT_SYMBOL:
printf( HB_I_("SYMBOL = %s "), ( *pBase )->item.asSymbol.value->szName );
break;
case HB_IT_POINTER:
printf( HB_I_("POINTER = %p "), ( *pBase )->item.asPointer.value );
break;
default:
printf( HB_I_("UNKNOWN = TYPE %i "), hb_itemType( *pBase ) );
break;
}
}
}
| estack.c | 511 |
VOID | hb_stackDispCall( void )
void hb_stackDispCall( void )
{
char buffer[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5 + 10 ]; /* additional 10 bytes for line info (%hu) overhead */
USHORT uiLine;
int iLevel;
HB_TRACE(HB_TR_DEBUG, ("hb_stackDispCall()"));
iLevel = 0;
while( hb_procinfo( iLevel++, buffer, &uiLine, NULL ) )
{
int l = strlen( buffer );
snprintf( buffer + l, sizeof( buffer ) - l, "(%hu)", uiLine );
hb_conOutErr( "Called from ", 0 );
hb_conOutErr( buffer, 0 );
hb_conOutErr( hb_conNewLine(), 0 );
}
}
/* ------------------------------------------------------------------------ */
/* The garbage collector interface */
| estack.c | 588 |
VOID | hb_vmIsLocalRef( void )
void hb_vmIsLocalRef( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmIsLocalRef()"));
if( hb_stack.pPos > hb_stack.pItems )
{
/* the eval stack is not cleared yet */
HB_ITEM_PTR * pItem = hb_stack.pPos - 1;
do
{
if( HB_IS_GCITEM( *pItem ) )
hb_gcItemRef( *pItem );
}
while( --pItem > hb_stack.pItems );
}
}
| estack.c | 613 |
eval.c |
Type | Function | Source | Line |
BOOL | hb_evalNew( PEVALINFO pEvalInfo, PHB_ITEM pItem )
BOOL hb_evalNew( PEVALINFO pEvalInfo, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_evalNew(%p, %p)", pEvalInfo, pItem));
if( pEvalInfo )
{
memset( pEvalInfo, 0, sizeof( EVALINFO ) );
pEvalInfo->pItems[ 0 ] = pItem;
pEvalInfo->paramCount = 0;
return TRUE;
}
else
return FALSE;
}
/* NOTE: CA-Cl*pper is buggy and will not check if more parameters are
added than the maximum (9). [vszakats] */
| eval.c | 72 |
BOOL | hb_evalPutParam( PEVALINFO pEvalInfo, PHB_ITEM pItem )
BOOL hb_evalPutParam( PEVALINFO pEvalInfo, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_evalPutParam(%p, %p)", pEvalInfo, pItem));
if( pEvalInfo && pItem && pEvalInfo->paramCount < HB_EVAL_PARAM_MAX_ )
{
pEvalInfo->pItems[ ++pEvalInfo->paramCount ] = pItem;
return TRUE;
}
else
return FALSE;
}
| eval.c | 101 |
PHB_ITEM | hb_evalLaunch( PEVALINFO pEvalInfo )
PHB_ITEM hb_evalLaunch( PEVALINFO pEvalInfo )
{
PHB_ITEM pResult = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_evalLaunch(%p)", pEvalInfo));
if( pEvalInfo )
{
PHB_ITEM pItem = pEvalInfo->pItems[ 0 ];
PHB_SYMB pSymbol = NULL;
USHORT uiParam = 0;
if( HB_IS_STRING( pItem ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value );
if( pDynSym )
{
pSymbol = pDynSym->pSymbol;
pItem = NULL;
}
}
else if( HB_IS_SYMBOL( pItem ) )
{
pSymbol = pItem->item.asSymbol.value;
pItem = NULL;
}
else if( HB_IS_BLOCK( pItem ) )
{
pSymbol = &hb_symEval;
}
if( pSymbol )
{
hb_vmPushSymbol( pSymbol );
if( pItem )
hb_vmPush( pItem );
else
hb_vmPushNil();
while( uiParam < pEvalInfo->paramCount )
hb_vmPush( pEvalInfo->pItems[ ++uiParam ] );
if( pItem )
hb_vmSend( uiParam );
else
hb_vmDo( uiParam );
pResult = hb_itemNew( hb_stackReturnItem() );
}
}
return pResult;
}
| eval.c | 115 |
BOOL | hb_evalRelease( PEVALINFO pEvalInfo )
BOOL hb_evalRelease( PEVALINFO pEvalInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_evalRelease(%p)", pEvalInfo));
if( pEvalInfo )
{
USHORT uiParam;
for( uiParam = 0; uiParam <= pEvalInfo->paramCount; uiParam++ )
{
hb_itemRelease( pEvalInfo->pItems[ uiParam ] );
pEvalInfo->pItems[ uiParam ] = NULL;
}
pEvalInfo->paramCount = 0;
return TRUE;
}
else
return FALSE;
}
| eval.c | 171 |
PHB_ITEM | hb_itemDo( PHB_ITEM pItem, ULONG ulPCount, ... )
PHB_ITEM hb_itemDo( PHB_ITEM pItem, ULONG ulPCount, ... )
{
PHB_ITEM pResult = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_itemDo(%p, %hu, ...)", pItem, ulPCount));
if( pItem )
{
PHB_SYMB pSymbol = NULL;
if( HB_IS_STRING( pItem ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value );
if( pDynSym )
{
pSymbol = pDynSym->pSymbol;
pItem = NULL;
}
}
else if( HB_IS_SYMBOL( pItem ) )
{
pSymbol = pItem->item.asSymbol.value;
pItem = NULL;
}
else if( HB_IS_BLOCK( pItem ) )
{
pSymbol = &hb_symEval;
}
if( pSymbol )
{
if( hb_vmRequestReenter() )
{
hb_vmPushSymbol( pSymbol );
if( pItem )
hb_vmPush( pItem );
else
hb_vmPushNil();
if( ulPCount )
{
ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
if( pItem )
hb_vmSend( ( USHORT ) ulPCount );
else
hb_vmDo( ( USHORT ) ulPCount );
pResult = hb_itemNew( hb_stackReturnItem() );
hb_vmRequestRestore();
}
}
}
return pResult;
}
| eval.c | 203 |
PHB_ITEM | hb_itemDoC( char * szFunc, ULONG ulPCount, ... )
PHB_ITEM hb_itemDoC( char * szFunc, ULONG ulPCount, ... )
{
PHB_ITEM pResult = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_itemDoC(%s, %hu, ...)", szFunc, ulPCount));
if( szFunc )
{
PHB_DYNS pDynSym = hb_dynsymFindName( szFunc );
if( pDynSym )
{
if( hb_vmRequestReenter() )
{
hb_vmPushSymbol( pDynSym->pSymbol );
hb_vmPushNil();
if( ulPCount )
{
ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
hb_vmDo( ( unsigned short ) ulPCount );
pResult = hb_itemNew( hb_stackReturnItem() );
hb_vmRequestRestore();
}
}
}
return pResult;
}
| eval.c | 273 |
VOID | hb_evalBlock0( PHB_ITEM pCodeBlock )
void hb_evalBlock0( PHB_ITEM pCodeBlock )
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pCodeBlock );
hb_vmFunction( 0 );
}
| eval.c | 313 |
VOID | hb_evalBlock1( PHB_ITEM pCodeBlock, PHB_ITEM pParam )
void hb_evalBlock1( PHB_ITEM pCodeBlock, PHB_ITEM pParam )
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pCodeBlock );
hb_vmPush( pParam );
hb_vmFunction( 1 );
}
| eval.c | 321 |
VOID | hb_evalBlock( PHB_ITEM pCodeBlock, ... )
void hb_evalBlock( PHB_ITEM pCodeBlock, ... )
{
va_list args;
unsigned int uiParams = 0;
PHB_ITEM pParam;
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pCodeBlock );
va_start( args, pCodeBlock );
while( ( pParam = va_arg( args, PHB_ITEM ) ) != NULL )
{
hb_vmPush( pParam );
uiParams++;
}
va_end( args );
hb_vmFunction( uiParams );
}
| eval.c | 330 |
HB_FUNC | HB_FORNEXT(void)
HB_FUNC( HB_FORNEXT ) /* nStart, nEnd | bEnd, bCode, nStep */
{
LONG lStart = hb_parnl( 1 ), lEnd;
PHB_ITEM pEndBlock = hb_param( 2, HB_IT_BLOCK );
PHB_ITEM pCodeBlock = hb_param( 3, HB_IT_BLOCK );
LONG lStep = ( hb_pcount() > 3 ) ? hb_parnl( 4 ) : 1;
if( pCodeBlock )
{
if( pEndBlock )
{
hb_evalBlock0( pEndBlock );
lEnd = hb_parnl( -1 );
while( lStart <= lEnd )
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pCodeBlock );
hb_vmPushLong( lStart );
hb_vmFunction( 1 );
lStart += lStep;
hb_evalBlock0( pEndBlock );
lEnd = hb_parnl( -1 );
}
}
else
{
lEnd = hb_parnl( 2 );
while( lStart <= lEnd )
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pCodeBlock );
hb_vmPushLong( lStart );
hb_vmFunction( 1 );
lStart += lStep;
}
}
}
}
| eval.c | 351 |
HB_FUNC | HB_EXECFROMARRAY(void)
HB_FUNC( HB_EXECFROMARRAY )
{
PHB_SYMB pExecSym = NULL;
PHB_ITEM pFunc = NULL;
PHB_ITEM pSelf = NULL;
PHB_ITEM pArray = NULL;
PHB_ITEM pItem;
ULONG ulParamOffset = 0;
USHORT usPCount = hb_pcount();
/* decode parameters */
if( usPCount )
{
PHB_ITEM pParam = hb_param( 1, HB_IT_ANY );
if( usPCount == 1 )
{
if( HB_IS_ARRAY( pParam ) && !HB_IS_OBJECT( pParam ) )
{
pArray = pParam;
pItem = hb_arrayGetItemPtr( pArray, 1 );
if( HB_IS_OBJECT( pItem ) )
{
pSelf = pItem;
pFunc = hb_arrayGetItemPtr( pArray, 2 );
ulParamOffset = 2;
}
else
{
pFunc = pItem;
ulParamOffset = 1;
}
}
else
pFunc = pParam;
}
else if( HB_IS_OBJECT( pParam ) && usPCount <= 3 )
{
pSelf = pParam;
pFunc = hb_param( 2, HB_IT_ANY );
pArray = hb_param( 3, HB_IT_ANY );
}
else if( usPCount == 2 )
{
pFunc = pParam;
pArray = hb_param( 2, HB_IT_ANY );
}
}
if( pFunc && ( !pArray || HB_IS_ARRAY( pArray ) ) )
{
if( HB_IS_SYMBOL( pFunc ) )
pExecSym = hb_itemGetSymbol( pFunc );
else if( HB_IS_STRING( pFunc ) )
pExecSym = hb_dynsymGet( hb_itemGetCPtr( pFunc ) )->pSymbol;
else if( HB_IS_BLOCK( pFunc ) && !pSelf )
{
pSelf = pFunc;
pExecSym = &hb_symEval;
}
}
if( pExecSym )
{
usPCount = 0;
hb_vmPushSymbol( pExecSym );
if( pSelf )
hb_vmPush( pSelf );
else
hb_vmPushNil();
if( pArray )
{
pItem = hb_arrayGetItemPtr( pArray, ++ulParamOffset );
while( pItem && usPCount < 255 )
{
hb_vmPush( pItem );
++usPCount;
pItem = hb_arrayGetItemPtr( pArray, ++ulParamOffset );
}
}
if( pSelf )
hb_vmSend( usPCount );
else
hb_vmDo( usPCount );
}
else
hb_errRT_BASE_SubstR( EG_ARG, 1099, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| eval.c | 394 |
BOOL | hb_execFromArray( PHB_ITEM pParam )
BOOL hb_execFromArray( PHB_ITEM pParam )
{
PHB_SYMB pExecSym = NULL;
PHB_ITEM pArray = NULL;
PHB_ITEM pSelf = NULL;
ULONG ulParamOffset = 0;
USHORT usPCount = 0;
if( pParam && HB_IS_ARRAY( pParam ) && !HB_IS_OBJECT( pParam ) )
{
pArray = pParam;
pParam = hb_arrayGetItemPtr( pArray, 1 );
if( HB_IS_OBJECT( pParam ) )
{
pSelf = pParam;
pParam = hb_arrayGetItemPtr( pArray, 2 );
ulParamOffset = 2;
}
else
ulParamOffset = 1;
}
if( pParam )
{
if( HB_IS_SYMBOL( pParam ) )
pExecSym = hb_itemGetSymbol( pParam );
else if( HB_IS_STRING( pParam ) )
pExecSym = hb_dynsymGet( hb_itemGetCPtr( pParam ) )->pSymbol;
else if( HB_IS_BLOCK( pParam ) && !pSelf )
{
pSelf = pParam;
pExecSym = &hb_symEval;
}
if( pExecSym )
{
hb_vmPushSymbol( pExecSym );
if( pSelf )
hb_vmPush( pSelf );
else
hb_vmPushNil();
if( pArray )
{
pParam = hb_arrayGetItemPtr( pArray, ++ulParamOffset );
while( pParam && usPCount < 255 )
{
hb_vmPush( pParam );
++usPCount;
pParam = hb_arrayGetItemPtr( pArray, ++ulParamOffset );
}
}
if( pSelf )
hb_vmSend( usPCount );
else
hb_vmDo( usPCount );
return TRUE;
}
}
hb_errRT_BASE_SubstR( EG_ARG, 1099, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return FALSE;
}
| eval.c | 505 |
evalhb.c |
Type | Function | Source | Line |
HB_FUNC | EVAL(void)
HB_FUNC( EVAL )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_BLOCK );
if( pItem )
{
USHORT uiPCount = hb_pcount();
USHORT uiParam;
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pItem );
/* NOTE: hb_param() function cannot be used for parameter access
* because we need to pass the references too.
* hb_param() is dereferencing the passed parameters
*/
for( uiParam = 2; uiParam <= uiPCount; uiParam++ )
{
hb_vmPush( hb_stackItemFromBase( uiParam ) );
}
hb_vmDo( uiPCount - 1 );
}
else
{
hb_errRT_BASE_SubstR( EG_NOMETHOD, 1004, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
}
| evalhb.c | 60 |
extend.c |
Type | Function | Source | Line |
HB_EXPORT PHB_ITEM | hb_param( int iParam, long lMask )
HB_EXPORT PHB_ITEM hb_param( int iParam, long lMask )
{
HB_TRACE(HB_TR_DEBUG, ("hb_param(%d, %ld)", iParam, lMask));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( pItem->type & HB_IT_BYREF )
{
pItem = hb_itemUnRef( pItem );
if( ( HB_TYPE ) lMask == HB_IT_BYREF )
return pItem;
}
if( ( pItem->type & ( HB_TYPE ) lMask ) || ( HB_TYPE ) lMask == HB_IT_ANY )
return pItem;
}
return NULL;
}
| extend.c | 81 |
HB_EXPORT PHB_ITEM | hb_paramError( int iParam )
HB_EXPORT PHB_ITEM hb_paramError( int iParam )
{
static HB_ITEM s_NIL;
PHB_ITEM pParam = hb_param( iParam, HB_IT_ANY );
if( pParam == NULL )
{
hb_itemClear( &s_NIL );
pParam = &s_NIL;
}
return pParam;
}
| extend.c | 103 |
HB_EXPORT BOOL | hb_extIsArray( int iParam )
HB_EXPORT BOOL hb_extIsArray( int iParam )
{
PHB_ITEM pItem;
if( iParam == -1 )
pItem = hb_stackReturnItem();
else if( iParam >= 0 && iParam <= hb_pcount() )
pItem = hb_stackItemFromBase( iParam );
else
return FALSE;
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
return HB_IS_ARRAY( pItem ) && !HB_ARRAY_OBJ( pItem );
}
| extend.c | 121 |
HB_EXPORT BOOL | hb_extIsObject( int iParam )
HB_EXPORT BOOL hb_extIsObject( int iParam )
{
PHB_ITEM pItem;
if( iParam == -1 )
pItem = hb_stackReturnItem();
else if( iParam >= 0 && iParam <= hb_pcount() )
pItem = hb_stackItemFromBase( iParam );
else
return FALSE;
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
return HB_IS_OBJECT( pItem );
}
| extend.c | 141 |
HB_EXPORT CHAR * | hb_parc( int iParam, ... )
HB_EXPORT char * hb_parc( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parc(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_STRING( pItem ) )
return pItem->item.asString.value;
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetCPtr( pItem, ulArrayIndex );
}
}
return ( char * ) NULL;
}
| extend.c | 161 |
HB_EXPORT CHAR * | hb_parcx( int iParam, ... )
HB_EXPORT char * hb_parcx( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parcx(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_STRING( pItem ) )
return pItem->item.asString.value;
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetCPtr( pItem, ulArrayIndex );
}
}
return "";
}
| extend.c | 190 |
HB_EXPORT ULONG | hb_parclen( int iParam, ... )
HB_EXPORT ULONG hb_parclen( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parclen(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_STRING( pItem ) )
return pItem->item.asString.length;
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetCLen( pItem, ulArrayIndex );
}
}
return 0;
}
| extend.c | 219 |
HB_EXPORT ULONG | hb_parcsiz( int iParam, ... )
HB_EXPORT ULONG hb_parcsiz( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parcsiz(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
/* NOTE: hb_parcsiz() will only work for strings passed by reference.
CA-Cl*pper works like this. [vszakats] */
if( HB_IS_BYREF( pItem ) )
{
pItem = hb_itemUnRef( pItem );
if( HB_IS_STRING( pItem ) )
return pItem->item.asString.length + 1;
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetCLen( pItem, ulArrayIndex ) + 1;
}
}
}
return 0;
}
| extend.c | 252 |
HB_EXPORT CHAR * | hb_pards( int iParam, ... )
HB_EXPORT char * hb_pards( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_pards(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_DATE( pItem ) )
return hb_dateDecStr( hb_stackDateBuffer(), pItem->item.asDate.value );
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetDS( pItem, ulArrayIndex, hb_stackDateBuffer() );
}
}
return hb_dateDecStr( hb_stackDateBuffer(), 0 );
}
| extend.c | 289 |
HB_EXPORT CHAR * | hb_pardsbuff( char * szDate, int iParam, ... )
HB_EXPORT char * hb_pardsbuff( char * szDate, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_pardsbuff(%p, %d, ...)", szDate, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_DATE( pItem ) )
return hb_dateDecStr( szDate, pItem->item.asDate.value );
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetDS( pItem, ulArrayIndex, szDate );
}
}
return hb_dateDecStr( szDate, 0 );
}
| extend.c | 320 |
HB_EXPORT LONG | hb_pardl( int iParam, ... )
HB_EXPORT LONG hb_pardl( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_pardl(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
{
pItem = hb_itemUnRef( pItem );
}
if( HB_IS_DATE( pItem ) )
{
return pItem->item.asDate.value;
}
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetDL( pItem, ulArrayIndex );
}
}
return hb_itemGetDL( NULL );
}
| extend.c | 351 |
HB_EXPORT INT | hb_parl( int iParam, ... )
HB_EXPORT int hb_parl( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parl(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_LOGICAL( pItem ) )
return pItem->item.asLogical.value ? 1 : 0;
else if( HB_IS_INTEGER( pItem ) )
return pItem->item.asInteger.value != 0 ? 1 : 0;
else if( HB_IS_LONG( pItem ) )
return pItem->item.asLong.value != 0 ? 1 : 0;
else if( HB_IS_DOUBLE( pItem ) )
return pItem->item.asDouble.value != 0.0 ? 1 : 0;
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetL( pItem, ulArrayIndex ) ? 1 : 0;
}
}
return 0;
}
| extend.c | 385 |
HB_EXPORT DOUBLE | hb_parnd( int iParam, ... )
HB_EXPORT double hb_parnd( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parnd(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_DOUBLE( pItem ) )
return pItem->item.asDouble.value;
else if( HB_IS_INTEGER( pItem ) )
return ( double ) pItem->item.asInteger.value;
else if( HB_IS_LONG( pItem ) )
return ( double ) pItem->item.asLong.value;
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetND( pItem, ulArrayIndex );
}
}
return 0;
}
| extend.c | 420 |
HB_EXPORT INT | hb_parni( int iParam, ... )
HB_EXPORT int hb_parni( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parni(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_INTEGER( pItem ) )
return pItem->item.asInteger.value;
else if( HB_IS_LONG( pItem ) )
return ( int ) pItem->item.asLong.value;
else if( HB_IS_DOUBLE( pItem ) )
return ( int ) pItem->item.asDouble.value;
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetNI( pItem, ulArrayIndex );
}
}
return 0;
}
| extend.c | 453 |
HB_EXPORT LONG | hb_parnl( int iParam, ... )
HB_EXPORT long hb_parnl( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parnl(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_LONG( pItem ) )
return ( long ) pItem->item.asLong.value;
else if( HB_IS_INTEGER( pItem ) )
return ( long ) pItem->item.asInteger.value;
else if( HB_IS_DOUBLE( pItem ) )
#ifdef __GNUC__
return ( long ) ( unsigned long ) pItem->item.asDouble.value;
#else
return ( long ) pItem->item.asDouble.value;
#endif
else if( HB_IS_DATE( pItem ) )
return ( long ) pItem->item.asDate.value;
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetNL( pItem, ulArrayIndex );
}
}
return 0;
}
| extend.c | 486 |
HB_EXPORT LONGLONG | hb_parnll( int iParam, ... )
HB_EXPORT LONGLONG hb_parnll( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parnll(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_LONG( pItem ) )
return ( LONGLONG ) pItem->item.asLong.value;
else if( HB_IS_INTEGER( pItem ) )
return ( LONGLONG ) pItem->item.asInteger.value;
else if( HB_IS_DOUBLE( pItem ) )
#ifdef __GNUC__
return ( LONGLONG ) ( ULONGLONG ) pItem->item.asDouble.value;
#else
return ( LONGLONG ) pItem->item.asDouble.value;
#endif
else if( HB_IS_DATE( pItem ) )
return ( LONGLONG ) pItem->item.asDate.value;
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetNLL( pItem, ulArrayIndex );
}
}
return 0;
}
| extend.c | 526 |
HB_EXPORT HB_LONG | hb_parnint( int iParam, ... )
HB_EXPORT HB_LONG hb_parnint( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parnint(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_LONG( pItem ) )
return ( HB_LONG ) pItem->item.asLong.value;
else if( HB_IS_INTEGER( pItem ) )
return ( HB_LONG ) pItem->item.asInteger.value;
else if( HB_IS_DOUBLE( pItem ) )
#ifdef __GNUC__
return ( HB_LONG ) ( HB_ULONG ) pItem->item.asDouble.value;
#else
return ( HB_LONG ) pItem->item.asDouble.value;
#endif
else if( HB_IS_DATE( pItem ) )
return ( HB_LONG ) pItem->item.asDate.value;
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetNInt( pItem, ulArrayIndex );
}
}
return 0;
}
| extend.c | 566 |
HB_EXPORT VOID * | hb_parptr( int iParam, ... )
HB_EXPORT void * hb_parptr( int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parptr(%d, ...)", iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_POINTER( pItem ) )
return pItem->item.asPointer.value;
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return hb_arrayGetPtr( pItem, ulArrayIndex );
}
}
return NULL;
}
| extend.c | 605 |
HB_EXPORT VOID * | hb_parptrGC( HB_GARBAGE_FUNC_PTR pFunc, int iParam, ... )
HB_EXPORT void * hb_parptrGC( HB_GARBAGE_FUNC_PTR pFunc, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parptrGC(%p,%d, ...)", pFunc, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_POINTER( pItem ) )
{
if( pItem->item.asPointer.collect &&
hb_gcFunc( pItem->item.asPointer.value ) == pFunc )
return pItem->item.asPointer.value;
}
else if( HB_IS_ARRAY( pItem ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
pItem = hb_arrayGetItemPtr( pItem, ulArrayIndex );
if( pItem && HB_IS_POINTER( pItem ) &&
pItem->item.asPointer.collect &&
hb_gcFunc( pItem->item.asPointer.value ) == pFunc )
return pItem->item.asPointer.value;
}
}
return NULL;
}
| extend.c | 634 |
HB_EXPORT ULONG | hb_parinfa( int iParamNum, ULONG uiArrayIndex )
HB_EXPORT ULONG hb_parinfa( int iParamNum, ULONG uiArrayIndex )
{
PHB_ITEM pArray;
HB_TRACE(HB_TR_DEBUG, ("hb_parinfa(%d, %lu)", iParamNum, uiArrayIndex));
pArray = hb_param( iParamNum, HB_IT_ARRAY );
if( pArray )
{
if( uiArrayIndex == 0 )
return hb_arrayLen( pArray );
else
return ( long ) hb_arrayGetType( pArray, uiArrayIndex );
}
else
return 0;
}
| extend.c | 671 |
HB_EXPORT ULONG | hb_parinfo( int iParam )
HB_EXPORT ULONG hb_parinfo( int iParam )
{
HB_TRACE(HB_TR_DEBUG, ("hb_parinfo(%d)", iParam));
if( iParam == 0 )
return ( ULONG ) hb_pcount();
else
{
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
HB_TYPE uiType = HB_ITEM_TYPE( pItem );
if( uiType & HB_IT_BYREF )
uiType |= HB_ITEM_TYPE( hb_itemUnRef( pItem ) );
return ( ULONG ) uiType;
}
else
return 0;
}
}
| extend.c | 690 |
HB_EXPORT VOID | hb_ret( void )
HB_EXPORT void hb_ret( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_ret()"));
hb_itemClear( hb_stackReturnItem() );
}
| extend.c | 714 |
HB_EXPORT VOID | hb_reta( ULONG ulLen )
HB_EXPORT void hb_reta( ULONG ulLen ) /* undocumented hb_reta() */
{
HB_TRACE(HB_TR_DEBUG, ("hb_reta(%lu)", ulLen));
hb_arrayNew( hb_stackReturnItem(), ulLen );
}
| extend.c | 722 |
HB_EXPORT VOID | hb_retc( const char * szText )
HB_EXPORT void hb_retc( const char * szText )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retc(%s)", szText));
hb_itemPutC( hb_stackReturnItem(), szText );
}
| extend.c | 730 |
HB_EXPORT VOID | hb_retc_null( void )
HB_EXPORT void hb_retc_null( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retc_null()"));
hb_itemPutC( hb_stackReturnItem(), NULL );
}
| extend.c | 738 |
HB_EXPORT VOID | hb_retc_buffer( char * szText )
HB_EXPORT void hb_retc_buffer( char * szText )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retc_buffer(%s)", szText));
hb_itemPutCPtr2( hb_stackReturnItem(), szText );
}
| extend.c | 746 |
HB_EXPORT VOID | hb_retc_const( const char * szText )
HB_EXPORT void hb_retc_const( const char * szText )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retc_const(%s)", szText));
hb_itemPutCConst( hb_stackReturnItem(), szText );
}
| extend.c | 754 |
HB_EXPORT VOID | hb_retclen( const char * szText, ULONG ulLen )
HB_EXPORT void hb_retclen( const char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retclen(%s, %lu)", szText, ulLen));
hb_itemPutCL( hb_stackReturnItem(), szText, ulLen );
}
| extend.c | 762 |
HB_EXPORT VOID | hb_retclen_buffer( char * szText, ULONG ulLen )
HB_EXPORT void hb_retclen_buffer( char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retclen_buffer(%s, %lu)", szText, ulLen));
hb_itemPutCLPtr( hb_stackReturnItem(), szText, ulLen );
}
| extend.c | 770 |
HB_EXPORT VOID | hb_retds( const char * szDate )
HB_EXPORT void hb_retds( const char * szDate )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retds(%s)", szDate));
hb_itemPutDS( hb_stackReturnItem(), szDate );
}
| extend.c | 780 |
HB_EXPORT VOID | hb_retd( int iYear, int iMonth, int iDay )
HB_EXPORT void hb_retd( int iYear, int iMonth, int iDay )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retd(%04i, %02i, %02i)", iYear, iMonth, iDay));
hb_itemPutD( hb_stackReturnItem(), iYear, iMonth, iDay );
}
| extend.c | 788 |
HB_EXPORT VOID | hb_retdl( long lJulian )
HB_EXPORT void hb_retdl( long lJulian )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retdl(%ld)", lJulian));
hb_itemPutDL( hb_stackReturnItem(), lJulian );
}
| extend.c | 796 |
HB_EXPORT VOID | hb_retl( int iLogical )
HB_EXPORT void hb_retl( int iLogical )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retl(%d)", iLogical));
hb_itemPutL( hb_stackReturnItem(), iLogical ? TRUE : FALSE );
}
| extend.c | 804 |
HB_EXPORT VOID | hb_retnd( double dNumber )
HB_EXPORT void hb_retnd( double dNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnd(%lf)", dNumber));
hb_itemPutND( hb_stackReturnItem(), dNumber );
}
| extend.c | 812 |
HB_EXPORT VOID | hb_retni( int iNumber )
HB_EXPORT void hb_retni( int iNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retni(%d)", iNumber));
hb_itemPutNI( hb_stackReturnItem(), iNumber );
}
| extend.c | 820 |
HB_EXPORT VOID | hb_retnl( long lNumber )
HB_EXPORT void hb_retnl( long lNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnl(%ld)", lNumber));
hb_itemPutNL( hb_stackReturnItem(), lNumber );
}
| extend.c | 828 |
HB_EXPORT VOID | hb_retnll( LONGLONG llNumber )
HB_EXPORT void hb_retnll( LONGLONG llNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnll(%" PFLL "d)", llNumber));
hb_itemPutNLL( hb_stackReturnItem(), llNumber );
}
| extend.c | 837 |
HB_EXPORT VOID | hb_retnint( HB_LONG lNumber )
HB_EXPORT void hb_retnint( HB_LONG lNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnl(%ld)", lNumber));
hb_itemPutNInt( hb_stackReturnItem(), lNumber );
}
| extend.c | 846 |
HB_EXPORT VOID | hb_retnlen( double dNumber, int iWidth, int iDec )
HB_EXPORT void hb_retnlen( double dNumber, int iWidth, int iDec )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnlen(%lf, %d, %d)", dNumber, iWidth, iDec));
hb_itemPutNLen( hb_stackReturnItem(), dNumber, iWidth, iDec );
}
| extend.c | 854 |
HB_EXPORT VOID | hb_retndlen( double dNumber, int iWidth, int iDec )
HB_EXPORT void hb_retndlen( double dNumber, int iWidth, int iDec )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retndlen(%lf, %d, %d)", dNumber, iWidth, iDec));
hb_itemPutNDLen( hb_stackReturnItem(), dNumber, iWidth, iDec );
}
| extend.c | 862 |
HB_EXPORT VOID | hb_retnilen( int iNumber, int iWidth )
HB_EXPORT void hb_retnilen( int iNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnilen(%d, %d)", iNumber, iWidth));
hb_itemPutNILen( hb_stackReturnItem(), iNumber, iWidth );
}
| extend.c | 870 |
HB_EXPORT VOID | hb_retnllen( long lNumber, int iWidth )
HB_EXPORT void hb_retnllen( long lNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnllen(%ld, %d)", lNumber, iWidth));
hb_itemPutNLLen( hb_stackReturnItem(), lNumber, iWidth );
}
| extend.c | 878 |
HB_EXPORT VOID | hb_retnlllen( LONGLONG llNumber, int iWidth )
HB_EXPORT void hb_retnlllen( LONGLONG llNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnlllen(%" PFLL "d, %d)", llNumber, iWidth));
hb_itemPutNLLLen( hb_stackReturnItem(), llNumber, iWidth );
}
| extend.c | 887 |
HB_EXPORT VOID | hb_retnintlen( HB_LONG lNumber, int iWidth )
HB_EXPORT void hb_retnintlen( HB_LONG lNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnintlen(%" PFHL "d, %d)", lNumber, iWidth));
hb_itemPutNIntLen( hb_stackReturnItem(), lNumber, iWidth );
}
| extend.c | 896 |
HB_EXPORT VOID | hb_retptr( void * pointer )
HB_EXPORT void hb_retptr( void * pointer )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retptr(%p)", pointer));
hb_itemPutPtr( hb_stackReturnItem(), pointer );
}
| extend.c | 904 |
HB_EXPORT VOID | hb_retptrGC( void * pointer )
HB_EXPORT void hb_retptrGC( void * pointer )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retptrGC(%p)", pointer));
hb_itemPutPtrGC( hb_stackReturnItem(), pointer );
}
| extend.c | 912 |
HB_EXPORT INT | hb_storc( char * szText, int iParam, ... )
HB_EXPORT int hb_storc( char * szText, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_storc(%s, %d, ...)", szText, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetC( pItem, va_arg( va, ULONG ), szText ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutC( pItem, szText );
return 1;
}
}
return 0;
}
| extend.c | 920 |
HB_EXPORT INT | hb_storclen( char * szText, ULONG ulLen, int iParam, ... )
HB_EXPORT int hb_storclen( char * szText, ULONG ulLen, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_storclen(%s, %lu, %d, ...)", szText, ulLen, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetCL( pItem, va_arg( va, ULONG ), szText, ulLen ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutCL( pItem, szText, ulLen );
return 1;
}
}
return 0;
}
| extend.c | 951 |
HB_EXPORT INT | hb_storclen_buffer( char * szText, ULONG ulLen, int iParam, ... )
HB_EXPORT int hb_storclen_buffer( char * szText, ULONG ulLen, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_storclen_buffer(%s, %lu, %d, ...)", szText, ulLen, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetCPtr( pItem, va_arg( va, ULONG ), szText, ulLen ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutCLPtr( pItem, szText, ulLen );
return 1;
}
}
return 0;
}
| extend.c | 982 |
HB_EXPORT INT | hb_stords( char * szDate, int iParam, ... )
HB_EXPORT int hb_stords( char * szDate, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stords(%s, %d, ...)", szDate, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetDS( pItem, va_arg( va, ULONG ), szDate ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutDS( pItem, szDate );
return 1;
}
}
return 0;
}
| extend.c | 1015 |
HB_EXPORT INT | hb_storl( int iLogical, int iParam, ... )
HB_EXPORT int hb_storl( int iLogical, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_storl(%d, %d, ...)", iLogical, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetL( pItem, va_arg( va, ULONG ), iLogical ? TRUE : FALSE ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutL( pItem, iLogical ? TRUE : FALSE );
return 1;
}
}
return 0;
}
| extend.c | 1046 |
HB_EXPORT INT | hb_storni( int iValue, int iParam, ... )
HB_EXPORT int hb_storni( int iValue, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_storni(%d, %d, ...)", iValue, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetNI( pItem, va_arg( va, ULONG ), iValue ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutNI( pItem, iValue );
return 1;
}
}
return 0;
}
| extend.c | 1077 |
HB_EXPORT INT | hb_stornl( long lValue, int iParam, ... )
HB_EXPORT int hb_stornl( long lValue, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stornl(%ld, %d, ...)", lValue, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetNL( pItem, va_arg( va, ULONG ), lValue ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutNL( pItem, lValue );
return 1;
}
}
return 0;
}
| extend.c | 1108 |
HB_EXPORT INT | hb_stornll( LONGLONG llValue, int iParam, ... )
HB_EXPORT int hb_stornll( LONGLONG llValue, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stornll(%" PFLL "d, %d, ...)", llValue, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetNLL( pItem, va_arg( va, ULONG ), llValue ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutNLL( pItem, llValue );
return 1;
}
}
return 0;
}
| extend.c | 1140 |
HB_EXPORT INT | hb_stornint( HB_LONG lValue, int iParam, ... )
HB_EXPORT int hb_stornint( HB_LONG lValue, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stornint(%" PFHL "d, %d, ...)", lValue, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetNInt( pItem, va_arg( va, ULONG ), lValue ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutNInt( pItem, lValue );
return 1;
}
}
return 0;
}
| extend.c | 1172 |
HB_EXPORT INT | hb_stornd( double dNumber, int iParam, ... )
HB_EXPORT int hb_stornd( double dNumber, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stornd(%lf, %d, ...)", dNumber, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetND( pItem, va_arg( va, ULONG ), dNumber ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutND( pItem, dNumber );
return 1;
}
}
return 0;
}
| extend.c | 1203 |
HB_EXPORT INT | hb_storptr( void * pointer, int iParam, ... )
HB_EXPORT int hb_storptr( void * pointer, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_storptr(%p, %d, ...)", pointer, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetPtr( pItem, va_arg( va, ULONG ), pointer ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutPtr( pItem, pointer );
return 1;
}
}
return 0;
}
| extend.c | 1234 |
HB_EXPORT INT | hb_storptrGC( void * pointer, int iParam, ... )
HB_EXPORT int hb_storptrGC( void * pointer, int iParam, ... )
{
HB_TRACE(HB_TR_DEBUG, ("hb_storptrGC(%p, %d, ...)", pointer, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
pItem = hb_itemUnRef( pItem );
if( HB_IS_ARRAY( pItem ) )
{
int iRetVal;
va_list va;
va_start( va, iParam );
iRetVal = hb_arraySetPtrGC( pItem, va_arg( va, ULONG ), pointer ) ? 1 : 0;
va_end( va );
return iRetVal;
}
else if( bByRef || iParam == -1 )
{
hb_itemPutPtrGC( pItem, pointer );
return 1;
}
}
return 0;
}
| extend.c | 1265 |
HB_EXPORT INT | hb_pcount( void )
HB_EXPORT int hb_pcount( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_pcount()"));
return ( int ) ( hb_stackBaseItem() )->item.asSymbol.paramcnt;
}
| extend.c | 1297 |
extrap.c |
Type | Function | Source | Line |
LONG WINAPI | hb_win32ExceptionHandler( struct _EXCEPTION_POINTERS * pExceptionInfo )
LONG WINAPI hb_win32ExceptionHandler( struct _EXCEPTION_POINTERS * pExceptionInfo )
{
char msg[ ( HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 32 ) * 32 ];
char buffer[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5 ];
char * ptr;
USHORT uiLine;
int iLevel;
FILE * hLog = hb_fopen( hb_setGetCPtr( HB_SET_HBOUTLOG ), "a+" );
if( hLog )
{
char szTime[ 9 ];
int iYear, iMonth, iDay;
hb_dateToday( &iYear, &iMonth, &iDay );
hb_dateTimeStr( szTime );
fprintf( hLog, HB_I_("Application Exception - %s\n"), hb_cmdargARGV()[0] );
fprintf( hLog, HB_I_("Terminated at: %04d.%02d.%02d %s\n"), iYear, iMonth, iDay, szTime );
if( *hb_setGetCPtr( HB_SET_HBOUTLOGINFO ) )
fprintf( hLog, HB_I_("Info: %s\n"), hb_setGetCPtr( HB_SET_HBOUTLOGINFO ) );
#if defined(HB_WINCE)
{
/* TODO */
}
#elif defined(HB_OS_WIN_64)
{
/* TODO */
}
#else
{
char errmsg[ 4096 ];
int errmsglen = sizeof( errmsg ) - 1;
char buf[ 32 ];
PEXCEPTION_RECORD pExceptionRecord = pExceptionInfo->ExceptionRecord;
PCONTEXT pCtx = pExceptionInfo->ContextRecord;
DWORD dwExceptCode = pExceptionInfo->ExceptionRecord->ExceptionCode;
unsigned char * pc;
unsigned int * sc;
unsigned int * ebp;
unsigned int eip;
unsigned int j;
int i;
snprintf( errmsg, errmsglen,
"\n"
" Exception Code:%08X\n"
" Exception Address:%08X\n"
" EAX:%08X EBX:%08X ECX:%08X EDX:%08X\n"
" ESI:%08X EDI:%08X EBP:%08X\n"
" CS:EIP:%04X:%08X SS:ESP:%04X:%08X\n"
" DS:%04X ES:%04X FS:%04X GS:%04X\n"
" Flags:%08X\n",
( UINT32 ) dwExceptCode, ( UINT32 ) pExceptionRecord->ExceptionAddress,
( UINT32 ) pCtx->Eax, ( UINT32 ) pCtx->Ebx, ( UINT32 ) pCtx->Ecx,
( UINT32 ) pCtx->Edx, ( UINT32 ) pCtx->Esi, ( UINT32 ) pCtx->Edi,
( UINT32 ) pCtx->Ebp,
( UINT32 ) pCtx->SegCs, ( UINT32 ) pCtx->Eip, ( UINT32 ) pCtx->SegSs,
( UINT32 ) pCtx->Esp, ( UINT32 ) pCtx->SegDs, ( UINT32 ) pCtx->SegEs,
( UINT32 ) pCtx->SegFs, ( UINT32 ) pCtx->SegGs,
( UINT32 ) pCtx->EFlags );
hb_strncat( errmsg, " CS:EIP:", errmsglen );
pc = ( unsigned char * ) pCtx->Eip;
for( i = 0; i < 16; i++ )
{
if( IsBadReadPtr( pc, 1 ) )
break;
snprintf( buf, sizeof( buf ) - 1, " %02X", ( int ) pc[ i ] );
hb_strncat( errmsg, buf, errmsglen );
}
hb_strncat( errmsg, "\n SS:ESP:", errmsglen );
sc = ( unsigned int * ) pCtx->Esp;
for( i = 0; i < 16; i++ )
{
if( IsBadReadPtr( sc, 4 ) )
break;
snprintf( buf, sizeof( buf ), " %08X", sc[ i ] );
hb_strncat( errmsg, buf, errmsglen );
}
hb_strncat( errmsg, "\n\n", errmsglen );
hb_strncat( errmsg, " C stack:\n", errmsglen );
hb_strncat( errmsg, " EIP: EBP: Frame: OldEBP, RetAddr, Params...\n", errmsglen );
eip = pCtx->Eip;
ebp = ( unsigned int * ) pCtx->Ebp;
if( ! IsBadWritePtr( ebp, 8 ) )
{
for( i = 0; i < 20; i++ )
{
if( ( unsigned int ) ebp % 4 != 0 || IsBadWritePtr( ebp, 40 ) || ( unsigned int ) ebp >= ebp[ 0 ] )
break;
snprintf( buf, sizeof( buf ), " %08X %08X ", ( int ) eip, ( int ) ebp );
hb_strncat( errmsg, buf, errmsglen );
for( j = 0; j < 10 && ( unsigned int )( ebp + j ) < ebp[ 0 ]; j++ )
{
snprintf( buf, sizeof( buf ), " %08X", ebp[ j ] );
hb_strncat( errmsg, buf, errmsglen );
}
hb_strncat( errmsg, "\n", errmsglen );
eip = ebp[ 1 ];
ebp = ( unsigned int * ) ebp[ 0 ];
}
hb_strncat( errmsg, "\n", errmsglen );
}
fwrite( errmsg, sizeof( char ), strlen( errmsg ), hLog );
}
#endif
}
msg[ 0 ] = '\0';
ptr = msg;
iLevel = 0;
while( hb_procinfo( iLevel++, buffer, &uiLine, NULL ) )
{
snprintf( ptr, sizeof( msg ) - ( ptr - msg ),
HB_I_("Called from %s(%hu)\n"), buffer, uiLine );
if( hLog )
fwrite( ptr, sizeof( *ptr ), strlen( ptr ), hLog );
ptr += strlen( ptr );
}
/* GUI */
{
LPTSTR lpStr = HB_TCHAR_CONVTO( msg );
MessageBox( NULL, lpStr, TEXT( HB_I_("Application Exception") ), MB_ICONSTOP );
HB_TCHAR_FREE( lpStr );
}
if( hLog )
{
fprintf( hLog, "------------------------------------------------------------------------\n");
fclose( hLog );
}
return EXCEPTION_CONTINUE_SEARCH; /* EXCEPTION_EXECUTE_HANDLER; */
}
#endif
#if defined(HB_OS_OS2)
static EXCEPTIONREGISTRATIONRECORD s_regRec; /* Exception Registration Record */
| extrap.c | 75 |
ULONG _SYSTEM | hb_os2ExceptionHandler( PEXCEPTIONREPORTRECORD p1, PEXCEPTIONREGISTRATIONRECORD p2, PCONTEXTRECORD p3, PVOID pv )
ULONG _System hb_os2ExceptionHandler( PEXCEPTIONREPORTRECORD p1,
PEXCEPTIONREGISTRATIONRECORD p2,
PCONTEXTRECORD p3,
PVOID pv )
{
HB_SYMBOL_UNUSED( p1 );
HB_SYMBOL_UNUSED( p2 );
HB_SYMBOL_UNUSED( p3 );
HB_SYMBOL_UNUSED( pv );
/* Don't print stack trace if inside unwind, normal process termination or process killed or
during debugging */
if( p1->ExceptionNum != XCPT_UNWIND && p1->ExceptionNum < XCPT_BREAKPOINT )
{
char buffer[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5 ];
USHORT uiLine;
int iLevel = 0;
fprintf( stderr, HB_I_("\nException %lx at address %p \n"), p1->ExceptionNum, p1->ExceptionAddress );
while( hb_procinfo( iLevel++, buffer, &uiLine, NULL ) )
fprintf( stderr, HB_I_("Called from %s(%hu)\n"), buffer, uiLine );
}
return XCPT_CONTINUE_SEARCH; /* Exception not resolved... */
}
| extrap.c | 225 |
VOID | hb_vmSetExceptionHandler( void )
void hb_vmSetExceptionHandler( void )
{
#if defined(HB_OS_WIN_32) && !defined(HB_WINCE)
{
LPTOP_LEVEL_EXCEPTION_FILTER ef = SetUnhandledExceptionFilter( hb_win32ExceptionHandler );
HB_SYMBOL_UNUSED( ef );
}
#elif defined(HB_OS_OS2) /* Add OS2TermHandler to this thread's chain of exception handlers */
{
APIRET rc; /* Return code */
memset( &s_regRec, 0, sizeof( s_regRec ) );
s_regRec.ExceptionHandler = ( ERR ) hb_os2ExceptionHandler;
rc = DosSetExceptionHandler( &s_regRec );
if( rc != NO_ERROR )
hb_errInternal( HB_EI_ERRUNRECOV, "Unable to setup exception handler (DosSetExceptionHandler())", NULL, NULL );
}
#endif
}
| extrap.c | 254 |
VOID | hb_vmUnsetExceptionHandler( void )
void hb_vmUnsetExceptionHandler( void )
{
#if defined(HB_OS_OS2) /* Add OS2TermHandler to this thread's chain of exception handlers */
{
APIRET rc; /* Return code */
/* I don't do any check on return code since harbour is exiting in any case */
rc = DosUnsetExceptionHandler( &s_regRec );
HB_SYMBOL_UNUSED( rc );
}
#endif
}
| extrap.c | 274 |
fm.c |
Type | Function | Source | Line |
HB_EXPORT VOID | hb_xsetfilename( char * szValue )
HB_EXPORT void hb_xsetfilename( char * szValue )
{
#ifdef HB_FM_STATISTICS
hb_strncpy( s_szFileName, szValue, sizeof( s_szFileName ) - 1 );
#else
HB_SYMBOL_UNUSED( szValue );
#endif
}
| fm.c | 175 |
HB_EXPORT VOID | hb_xsetinfo( char * szValue )
HB_EXPORT void hb_xsetinfo( char * szValue )
{
#ifdef HB_FM_STATISTICS
hb_strncpy( s_szInfo, szValue, sizeof( s_szInfo ) - 1 );
#else
HB_SYMBOL_UNUSED( szValue );
#endif
}
| fm.c | 184 |
HB_EXPORT VOID * | hb_xalloc( ULONG ulSize )
HB_EXPORT void * hb_xalloc( ULONG ulSize ) /* allocates fixed memory, returns NULL on failure */
{
PHB_MEMINFO pMem;
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xalloc(%lu)", ulSize));
if( ulSize == 0 )
hb_errInternal( HB_EI_XALLOCNULLSIZE, NULL, NULL, NULL );
pMem = ( PHB_MEMINFO ) malloc( HB_ALLOC_SIZE( ulSize ) );
if( ! pMem )
return pMem;
#ifdef HB_FM_STATISTICS
if( ! s_pFirstBlock )
{
pMem->pPrevBlock = NULL;
s_pFirstBlock = pMem;
}
else
{
pMem->pPrevBlock = s_pLastBlock;
s_pLastBlock->pNextBlock = pMem;
}
s_pLastBlock = pMem;
pMem->pNextBlock = NULL;
pMem->u32Signature = HB_MEMINFO_SIGNATURE;
HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize );
pMem->ulSize = ulSize; /* size of the memory block */
if( hb_tr_level() >= HB_TR_DEBUG )
{
/* NOTE: PRG line number/procname is not very useful during hunting
* for memory leaks - this is why we are using the previously stored
* function/line info - this is a location of code that called
* hb_xalloc/hb_xgrab
*/
pMem->uiProcLine = hb_tr_line_; /* C line number */
hb_strncpy( pMem->szProcName, hb_tr_file_, HB_SYMBOL_NAME_LEN );
}
else
{
hb_stackBaseProcInfo( pMem->szProcName, &pMem->uiProcLine );
}
s_lMemoryConsumed += ulSize + sizeof( HB_COUNTER );
if( s_lMemoryMaxConsumed < s_lMemoryConsumed )
s_lMemoryMaxConsumed = s_lMemoryConsumed;
s_lMemoryBlocks++;
if( s_lMemoryMaxBlocks < s_lMemoryBlocks )
s_lMemoryMaxBlocks = s_lMemoryBlocks;
#ifdef HB_PARANOID_MEM_CHECK
memset( HB_MEM_PTR( pMem ), HB_MEMFILER, ulSize );
#endif
#endif
* HB_COUNTER_PTR( HB_MEM_PTR( pMem ) ) = 1;
return HB_MEM_PTR( pMem );
}
| fm.c | 194 |
HB_EXPORT VOID * | hb_xgrab( ULONG ulSize )
HB_EXPORT void * hb_xgrab( ULONG ulSize ) /* allocates fixed memory, exits on failure */
{
PHB_MEMINFO pMem;
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xgrab(%lu)", ulSize));
if( ulSize == 0 )
hb_errInternal( HB_EI_XGRABNULLSIZE, NULL, NULL, NULL );
pMem = ( PHB_MEMINFO ) malloc( HB_ALLOC_SIZE( ulSize ) );
if( ! pMem )
hb_errInternal( HB_EI_XGRABALLOC, NULL, NULL, NULL );
#ifdef HB_FM_STATISTICS
if( ! s_pFirstBlock )
{
pMem->pPrevBlock = NULL;
s_pFirstBlock = pMem;
}
else
{
pMem->pPrevBlock = s_pLastBlock;
s_pLastBlock->pNextBlock = pMem;
}
s_pLastBlock = pMem;
pMem->pNextBlock = NULL;
pMem->u32Signature = HB_MEMINFO_SIGNATURE;
HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize );
pMem->ulSize = ulSize; /* size of the memory block */
if( hb_tr_level() >= HB_TR_DEBUG )
{
/* NOTE: PRG line number/procname is not very useful during hunting
* for memory leaks - this is why we are using the previously stored
* function/line info - this is a location of code that called
* hb_xalloc/hb_xgrab
*/
pMem->uiProcLine = hb_tr_line_; /* C line number */
hb_strncpy( pMem->szProcName, hb_tr_file_, HB_SYMBOL_NAME_LEN );
}
else
{
hb_stackBaseProcInfo( pMem->szProcName, &pMem->uiProcLine );
}
s_lMemoryConsumed += ulSize + sizeof( HB_COUNTER );
if( s_lMemoryMaxConsumed < s_lMemoryConsumed )
s_lMemoryMaxConsumed = s_lMemoryConsumed;
s_lMemoryBlocks++;
if( s_lMemoryMaxBlocks < s_lMemoryBlocks )
s_lMemoryMaxBlocks = s_lMemoryBlocks;
#ifdef HB_PARANOID_MEM_CHECK
memset( HB_MEM_PTR( pMem ), HB_MEMFILER, ulSize );
#endif
#endif
* HB_COUNTER_PTR( HB_MEM_PTR( pMem ) ) = 1;
return HB_MEM_PTR( pMem );
}
| fm.c | 259 |
HB_EXPORT VOID * | hb_xrealloc( void * pMem, ULONG ulSize )
HB_EXPORT void * hb_xrealloc( void * pMem, ULONG ulSize ) /* reallocates memory */
{
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xrealloc(%p, %lu)", pMem, ulSize));
#if 0
/* disabled to make hb_xrealloc() ANSI-C realloc() compatible */
if( ! pMem )
hb_errInternal( HB_EI_XREALLOCNULL, NULL, NULL, NULL );
if( ulSize == 0 )
hb_errInternal( HB_EI_XREALLOCNULLSIZE, NULL, NULL, NULL );
#endif
#ifdef HB_FM_STATISTICS
if( pMem == NULL )
{
if( ulSize == 0 )
hb_errInternal( HB_EI_XREALLOCNULLSIZE, NULL, NULL, NULL );
return hb_xgrab( ulSize );
}
else if( ulSize == 0 )
{
hb_xfree( pMem );
return NULL;
}
else
{
PHB_MEMINFO pMemBlock;
ULONG ulMemSize;
pMemBlock = HB_FM_PTR( pMem );
if( pMemBlock->u32Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XREALLOCINV, NULL, NULL, NULL );
ulMemSize = pMemBlock->ulSize;
if( HB_FM_GETSIG( pMem, ulMemSize ) != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XMEMOVERFLOW, NULL, NULL, NULL );
HB_FM_CLRSIG( pMem, ulMemSize );
#ifdef HB_PARANOID_MEM_CHECK
pMem = malloc( HB_ALLOC_SIZE( ulSize ) );
if( pMem )
{
if( ulSize > ulMemSize )
{
memcpy( pMem, pMemBlock, HB_ALLOC_SIZE( ulMemSize ) );
memset( ( BYTE * ) pMem + HB_ALLOC_SIZE( ulMemSize ), HB_MEMFILER, ulSize - ulMemSize );
}
else
memcpy( pMem, pMemBlock, HB_ALLOC_SIZE( ulSize ) );
}
memset( pMemBlock, HB_MEMFILER, HB_ALLOC_SIZE( ulMemSize ) );
free( pMemBlock );
#else
pMem = realloc( pMemBlock, HB_ALLOC_SIZE( ulSize ) );
#endif
s_lMemoryConsumed += ( ulSize - ulMemSize );
if( s_lMemoryMaxConsumed < s_lMemoryConsumed )
s_lMemoryMaxConsumed = s_lMemoryConsumed;
if( ! pMem )
hb_errInternal( HB_EI_XREALLOC, NULL, NULL, NULL );
( ( PHB_MEMINFO ) pMem )->ulSize = ulSize; /* size of the memory block */
HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize );
if( ( ( PHB_MEMINFO ) pMem )->pPrevBlock )
( ( PHB_MEMINFO ) pMem )->pPrevBlock->pNextBlock = ( PHB_MEMINFO ) pMem;
if( ( ( PHB_MEMINFO ) pMem )->pNextBlock )
( ( PHB_MEMINFO ) pMem )->pNextBlock->pPrevBlock = ( PHB_MEMINFO ) pMem;
if( s_pFirstBlock == pMemBlock )
s_pFirstBlock = ( PHB_MEMINFO ) pMem;
if( s_pLastBlock == pMemBlock )
s_pLastBlock = ( PHB_MEMINFO ) pMem;
}
#else
if( pMem == NULL )
{
if( ulSize == 0 )
hb_errInternal( HB_EI_XREALLOCNULLSIZE, NULL, NULL, NULL );
pMem = malloc( HB_ALLOC_SIZE( ulSize ) );
}
else if( ulSize == 0 )
{
free( HB_FM_PTR( pMem ) );
return NULL;
}
else
{
pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE( ulSize ) );
}
if( !pMem )
hb_errInternal( HB_EI_XREALLOC, NULL, NULL, NULL );
#endif
return HB_MEM_PTR( pMem );
}
| fm.c | 324 |
HB_EXPORT VOID | hb_xfree( void * pMem )
HB_EXPORT void hb_xfree( void * pMem ) /* frees fixed memory */
{
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xfree(%p)", pMem));
if( pMem )
{
#ifdef HB_FM_STATISTICS
PHB_MEMINFO pMemBlock = HB_FM_PTR( pMem );
if( pMemBlock->u32Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XFREEINV, NULL, NULL, NULL );
if( HB_FM_GETSIG( pMem, pMemBlock->ulSize ) != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XMEMOVERFLOW, NULL, NULL, NULL );
s_lMemoryConsumed -= pMemBlock->ulSize + sizeof( HB_COUNTER );
s_lMemoryBlocks--;
if( pMemBlock->pPrevBlock )
pMemBlock->pPrevBlock->pNextBlock = pMemBlock->pNextBlock;
else
s_pFirstBlock = pMemBlock->pNextBlock;
if( pMemBlock->pNextBlock )
pMemBlock->pNextBlock->pPrevBlock = pMemBlock->pPrevBlock;
else
s_pLastBlock = pMemBlock->pPrevBlock;
pMemBlock->u32Signature = 0;
HB_FM_CLRSIG( pMem, pMemBlock->ulSize );
#ifdef HB_PARANOID_MEM_CHECK
memset( pMemBlock, HB_MEMFILER, HB_ALLOC_SIZE( pMemBlock->ulSize ) );
#endif
free( ( void * ) pMemBlock );
#else
free( HB_FM_PTR( pMem ) );
#endif
}
else
hb_errInternal( HB_EI_XFREENULL, NULL, NULL, NULL );
}
| fm.c | 429 |
VOID | hb_xRefInc( void * pMem )
void hb_xRefInc( void * pMem )
{
++( * HB_COUNTER_PTR( pMem ) );
}
| fm.c | 479 |
BOOL | hb_xRefDec( void * pMem )
BOOL hb_xRefDec( void * pMem )
{
return --( * HB_COUNTER_PTR( pMem ) ) == 0;
}
| fm.c | 486 |
VOID | hb_xRefFree( void * pMem )
void hb_xRefFree( void * pMem )
{
#ifdef HB_FM_STATISTICS
if( HB_FM_PTR( pMem )->u32Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XFREEINV, NULL, NULL, NULL );
if( --( * HB_COUNTER_PTR( pMem ) ) == 0 )
hb_xfree( pMem );
#else
if( --( * HB_COUNTER_PTR( pMem ) ) == 0 )
free( HB_FM_PTR( pMem ) );
#endif
}
| fm.c | 493 |
HB_COUNTER | hb_xRefCount( void * pMem )
HB_COUNTER hb_xRefCount( void * pMem )
{
return * HB_COUNTER_PTR( pMem );
}
| fm.c | 513 |
VOID * | hb_xRefResize( void * pMem, ULONG ulSave, ULONG ulSize )
void * hb_xRefResize( void * pMem, ULONG ulSave, ULONG ulSize )
{
#ifdef HB_FM_STATISTICS
if( * HB_COUNTER_PTR( pMem ) > 1 )
{
void * pMemNew = hb_xgrab( ulSize );
--( * HB_COUNTER_PTR( pMem ) );
memcpy( pMemNew, pMem, HB_MIN( ulSave, ulSize ) );
return pMemNew;
}
return hb_xrealloc( pMem, ulSize );
#else
if( * HB_COUNTER_PTR( pMem ) > 1 )
{
void * pMemNew = malloc( HB_ALLOC_SIZE( ulSize ) );
if( pMemNew )
{
--( * HB_COUNTER_PTR( pMem ) );
* HB_COUNTER_PTR( HB_MEM_PTR( pMemNew ) ) = 1;
memcpy( HB_MEM_PTR( pMemNew ), pMem, HB_MIN( ulSave, ulSize ) );
return HB_MEM_PTR( pMemNew );
}
}
else
{
pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE ( ulSize ) );
if( pMem )
return HB_MEM_PTR( pMem );
}
hb_errInternal( HB_EI_XREALLOC, NULL, NULL, NULL );
return NULL;
#endif
}
| fm.c | 520 |
HB_EXPORT ULONG | hb_xsize( void * pMem )
HB_EXPORT ULONG hb_xsize( void * pMem ) /* returns the size of an allocated memory block */
{
HB_TRACE(HB_TR_DEBUG, ("hb_xsize(%p)", pMem));
#ifdef HB_FM_STATISTICS
return HB_FM_PTR( pMem )->ulSize;
#else
HB_SYMBOL_UNUSED( pMem );
return 0;
#endif
}
| fm.c | 564 |
HB_EXPORT VOID | hb_xinit( void )
HB_EXPORT void hb_xinit( void ) /* Initialize fixed memory subsystem */
{
HB_TRACE(HB_TR_DEBUG, ("hb_xinit()"));
}
| fm.c | 577 |
STATIC CHAR * | hb_mem2str( char * membuffer, void * pMem, UINT uiSize )
static char * hb_mem2str( char * membuffer, void * pMem, UINT uiSize )
{
BYTE *cMem = ( BYTE * ) pMem;
UINT uiIndex, uiPrintable;
uiPrintable = 0;
for( uiIndex = 0; uiIndex < uiSize; uiIndex++ )
if( ( cMem[ uiIndex ] & 0x60 ) != 0 )
uiPrintable++;
if( uiPrintable * 100 / uiSize > 70 ) /* more then 70% printable chars */
{
/* format as string of original chars */
for( uiIndex = 0; uiIndex < uiSize; uiIndex++ )
if( cMem[ uiIndex ] >= ' ' )
membuffer[ uiIndex ] = cMem[ uiIndex ];
else
membuffer[ uiIndex ] = '.';
membuffer[ uiIndex ] = '\0';
}
else
{
/* format as hex */
for( uiIndex = 0; uiIndex < uiSize; uiIndex++ )
{
int lownibble, hinibble;
hinibble = cMem[ uiIndex ] >> 4;
lownibble = cMem[ uiIndex ] & 0x0F;
membuffer[ uiIndex * 2 ] = hinibble <= 9 ?
( '0' + hinibble ) : ( 'A' + hinibble - 10 );
membuffer[ uiIndex * 2 + 1 ] = lownibble <= 9 ?
( '0' + lownibble ) : ( 'A' + lownibble - 10 );
}
membuffer[ uiIndex * 2 ] = '\0';
}
return membuffer;
}
| fm.c | 586 |
HB_EXPORT VOID | hb_xexit( void )
HB_EXPORT void hb_xexit( void ) /* Deinitialize fixed memory subsystem */
{
HB_TRACE(HB_TR_DEBUG, ("hb_xexit()"));
if( s_lMemoryBlocks || hb_cmdargCheck( "INFO" ) )
{
char membuffer[ HB_MAX_MEM2STR_BLOCK * 2 + 1 ]; /* multiplied by 2 to allow hex format */
PHB_MEMINFO pMemBlock;
USHORT ui;
char buffer[ 100 ];
FILE * hLog = NULL;
if( s_lMemoryBlocks && s_szFileName[ 0 ] )
hLog = hb_fopen( s_szFileName, "a+" );
hb_conOutErr( hb_conNewLine(), 0 );
hb_conOutErr( "----------------------------------------", 0 );
hb_conOutErr( hb_conNewLine(), 0 );
snprintf( buffer, sizeof( buffer ), HB_I_("Total memory allocated: %li bytes (%li block(s))"), s_lMemoryMaxConsumed, s_lMemoryMaxBlocks );
hb_conOutErr( buffer, 0 );
if( s_lMemoryBlocks )
{
if( hLog )
{
char szTime[ 9 ];
int iYear, iMonth, iDay;
hb_dateToday( &iYear, &iMonth, &iDay );
hb_dateTimeStr( szTime );
fprintf( hLog, HB_I_("Application Memory Allocation Report - %s\n"), hb_cmdargARGV()[0] );
fprintf( hLog, HB_I_("Terminated at: %04d.%02d.%02d %s\n"), iYear, iMonth, iDay, szTime );
if( s_szInfo[ 0 ] )
fprintf( hLog, HB_I_("Info: %s\n"), s_szInfo );
fprintf( hLog, "%s\n", buffer );
}
hb_conOutErr( hb_conNewLine(), 0 );
snprintf( buffer, sizeof( buffer ), HB_I_("Warning, memory allocated but not released: %li bytes (%li block(s))"), s_lMemoryConsumed, s_lMemoryBlocks );
hb_conOutErr( buffer, 0 );
if( hLog )
fprintf( hLog, "%s\n", buffer );
}
hb_conOutErr( hb_conNewLine(), 0 );
for( ui = 1, pMemBlock = s_pFirstBlock; pMemBlock; pMemBlock = pMemBlock->pNextBlock, ++ui )
{
HB_TRACE( HB_TR_ERROR, ( "Block %i (size %lu) %s(%i), \"%s\"", ui,
pMemBlock->ulSize, pMemBlock->szProcName, pMemBlock->uiProcLine,
hb_mem2str( membuffer, ( char * ) pMemBlock + HB_MEMINFO_SIZE,
HB_MIN( pMemBlock->ulSize, HB_MAX_MEM2STR_BLOCK ) ) ) );
if( hLog )
{
fprintf( hLog, HB_I_("Block %i %p (size %lu) %s(%i), \"%s\"\n"), ui,
( char * ) pMemBlock + HB_MEMINFO_SIZE,
pMemBlock->ulSize, pMemBlock->szProcName, pMemBlock->uiProcLine,
hb_mem2str( membuffer, ( char * ) pMemBlock + HB_MEMINFO_SIZE,
HB_MIN( pMemBlock->ulSize, HB_MAX_MEM2STR_BLOCK ) ) );
}
}
if( hLog )
{
fprintf( hLog, "------------------------------------------------------------------------\n");
fclose( hLog );
}
}
}
| fm.c | 626 |
HB_EXPORT VOID | hb_xexit( void )
HB_EXPORT void hb_xexit( void ) /* Deinitialize fixed memory subsystem */
{
HB_TRACE(HB_TR_DEBUG, ("hb_xexit()"));
}
#endif
/* hb_xmemcpy and hb_xmemset are only needed when
unsigned int and unsigned long differ in length */
| fm.c | 701 |
VOID * | hb_xmemcpy( void * pDestArg, void * pSourceArg, ULONG ulLen )
void * hb_xmemcpy( void * pDestArg, void * pSourceArg, ULONG ulLen )
{
BYTE * pDest;
BYTE * pSource;
ULONG ulRemaining;
int iCopySize;
HB_TRACE(HB_TR_DEBUG, ("hb_xmemcpy(%p, %p, %lu)", pDestArg, pSourceArg, ulLen));
pDest = ( BYTE * ) pDestArg;
pSource = ( BYTE * ) pSourceArg;
ulRemaining = ulLen;
while( ulRemaining )
{
/* Overcome the memcpy() size_t limitation */
if( ulRemaining > UINT_MAX )
{
iCopySize = UINT_MAX;
ulRemaining -= ( ULONG ) iCopySize;
}
else
{
iCopySize = ( int ) ulRemaining;
ulRemaining = 0;
}
memcpy( pDest, pSource, iCopySize );
pDest += iCopySize;
pSource += iCopySize;
}
return pDestArg;
}
| fm.c | 720 |
VOID * | hb_xmemset( void * pDestArg, int iFill, ULONG ulLen )
void * hb_xmemset( void * pDestArg, int iFill, ULONG ulLen )
{
BYTE * pDest;
ULONG ulRemaining;
int iSetSize;
HB_TRACE(HB_TR_DEBUG, ("hb_xmemset(%p, %d, %lu)", pDestArg, iFill, ulLen));
pDest = ( BYTE * ) pDestArg;
ulRemaining = ulLen;
while( ulRemaining )
{
/* Overcome the memset() size_t limitation */
if( ulRemaining > UINT_MAX )
{
iSetSize = UINT_MAX;
ulRemaining -= ( ULONG ) iSetSize;
}
else
{
iSetSize = ( int ) ulRemaining;
ulRemaining = 0;
}
memset( pDest, iFill, iSetSize );
pDest += iSetSize;
}
return pDestArg;
}
| fm.c | 756 |
ULONG | hb_xquery( USHORT uiMode )
ULONG hb_xquery( USHORT uiMode )
{
ULONG ulResult;
HB_TRACE(HB_TR_DEBUG, ("hb_xquery(%hu)", uiMode));
/* TODO: Return the correct values instead of 9999 [vszakats] */
switch( uiMode )
{
case HB_MEM_CHAR: /* (Free Variable Space [KB]) */
#if defined(HB_OS_WIN_32)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = memorystatus.dwAvailPhys / 1024;
}
#elif defined(HB_OS_OS2)
{
ULONG ulSysInfo = 0;
if( DosQuerySysInfo( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR )
ulResult = 0;
else
ulResult = ulSysInfo / 1024;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_BLOCK: /* (Largest String [KB]) */
#if defined(HB_OS_WIN_32)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = HB_MIN( memorystatus.dwAvailPhys, ULONG_MAX ) / 1024;
}
#elif defined(HB_OS_OS2)
{
ULONG ulSysInfo = 0;
if( DosQuerySysInfo( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR )
ulResult = 0;
else
ulResult = HB_MIN( ulSysInfo, ULONG_MAX ) / 1024;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_RUN: /* (RUN Memory [KB]) */
#if defined(HB_OS_WIN_32)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = memorystatus.dwAvailPhys / 1024;
}
#elif defined(HB_OS_OS2)
{
ULONG ulSysInfo = 0;
if( DosQuerySysInfo( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR )
ulResult = 0;
else
ulResult = ulSysInfo / 1024;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_VM: /* UNDOCUMENTED! (Virtual Memory [KB]) */
#if defined(HB_OS_WIN_32)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = memorystatus.dwAvailVirtual / 1024;
}
#elif defined(HB_OS_OS2)
{
ULONG ulSysInfo = 0;
if( DosQuerySysInfo( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR )
ulResult = 0;
else
ulResult = ulSysInfo / 1024;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_EMS: /* UNDOCUMENTED! (Free Expanded Memory [KB]) (?) */
#if defined(HB_OS_WIN_32) || defined(HB_OS_OS2)
ulResult = 0;
#else
ulResult = 9999;
#endif
break;
case HB_MEM_FM: /* UNDOCUMENTED! (Fixed Memory/Heap [KB]) (?) */
#if defined(HB_OS_WIN_32)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = memorystatus.dwTotalPhys / 1024;
}
#elif defined(HB_OS_OS2)
{
ULONG ulSysInfo = 0;
if( DosQuerySysInfo( QSV_MAXPRMEM, QSV_MAXPRMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR )
ulResult = 0;
else
ulResult = ulSysInfo / 1024;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_FMSEGS: /* UNDOCUMENTED! (Segments in Fixed Memory/Heap) (?) */
#if defined(HB_OS_WIN_32) || defined(HB_OS_OS2)
ulResult = 1;
#else
ulResult = 9999;
#endif
break;
case HB_MEM_SWAP: /* UNDOCUMENTED! (Free Swap Memory [KB]) */
#if defined(HB_OS_WIN_32)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = memorystatus.dwAvailPageFile / 1024;
}
#elif defined(HB_OS_OS2)
{
/* NOTE: There is no way to know how much a swap file can grow on an
OS/2 system. I think we should return free space on DASD
media which contains swap file [maurilio.longo] */
ulResult = 9999;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_CONV: /* UNDOCUMENTED! (Free Conventional [KB]) */
#if defined(HB_OS_WIN_32) || defined(HB_OS_OS2)
ulResult = 0;
#else
ulResult = 9999;
#endif
break;
case HB_MEM_EMSUSED: /* UNDOCUMENTED! (Used Expanded Memory [KB]) (?) */
ulResult = 0;
break;
case HB_MEM_USED: /* Harbour extension (Memory used [bytes]) */
#ifdef HB_FM_STATISTICS
ulResult = s_lMemoryConsumed;
#else
ulResult = 0;
#endif
break;
case HB_MEM_BLOCKS: /* Harbour extension (Memory blocks used) */
#ifdef HB_FM_STATISTICS
ulResult = s_lMemoryBlocks;
#else
ulResult = 0;
#endif
break;
case HB_MEM_USEDMAX: /* Harbour extension (Maximum memory used [bytes]) */
#ifdef HB_FM_STATISTICS
ulResult = s_lMemoryMaxConsumed;
#else
ulResult = 0;
#endif
break;
case HB_MEM_STACKITEMS: /* Harbour extension (Total items allocated for the stack) */
ulResult = hb_stackTotalItems();
break;
case HB_MEM_STACK: /* Harbour extension (Total memory size used by the stack [bytes]) */
ulResult = hb_stackTotalItems() * sizeof( HB_ITEM );
break;
case HB_MEM_STACK_TOP : /* Harbour extension (Total items currently on the stack) */
ulResult = hb_stackTopOffset( );
break;
default:
ulResult = 0;
}
return ulResult;
}
| fm.c | 788 |
HB_FUNC | MEMORY(void)
HB_FUNC( MEMORY )
{
hb_retnl( hb_xquery( hb_parni( 1 ) ) );
}
| fm.c | 993 |
HB_FUNC | HB_FM_STAT(void)
HB_FUNC( HB_FM_STAT ) {}
| fm.c | 999 |
HB_FUNC | HB_FM_NOSTAT(void)
HB_FUNC( HB_FM_NOSTAT ) {}
| fm.c | 1001 |
garbage.c |
Type | Function | Source | Line |
STATIC VOID | hb_gcLink( HB_GARBAGE_PTR *pList, HB_GARBAGE_PTR pAlloc )
static void hb_gcLink( HB_GARBAGE_PTR *pList, HB_GARBAGE_PTR pAlloc )
{
if( *pList )
{
/* add new block at the logical end of list */
pAlloc->pNext = *pList;
pAlloc->pPrev = (*pList)->pPrev;
pAlloc->pPrev->pNext = pAlloc;
(*pList)->pPrev = pAlloc;
}
else
{
*pList = pAlloc->pNext = pAlloc->pPrev = pAlloc;
}
}
| garbage.c | 135 |
STATIC VOID | hb_gcUnlink( HB_GARBAGE_PTR *pList, HB_GARBAGE_PTR pAlloc )
static void hb_gcUnlink( HB_GARBAGE_PTR *pList, HB_GARBAGE_PTR pAlloc )
{
pAlloc->pPrev->pNext = pAlloc->pNext;
pAlloc->pNext->pPrev = pAlloc->pPrev;
if( *pList == pAlloc )
{
*pList = pAlloc->pNext;
if( *pList == pAlloc )
*pList = NULL; /* this was the last block */
}
}
| garbage.c | 151 |
VOID * | hb_gcAlloc( ULONG ulSize, HB_GARBAGE_FUNC_PTR pCleanupFunc )
void * hb_gcAlloc( ULONG ulSize, HB_GARBAGE_FUNC_PTR pCleanupFunc )
{
HB_GARBAGE_PTR pAlloc;
pAlloc = HB_GARBAGE_NEW( ulSize );
if( pAlloc )
{
hb_gcLink( &s_pCurrBlock, pAlloc );
pAlloc->pFunc = pCleanupFunc;
pAlloc->locked = 0;
pAlloc->used = s_uUsedFlag;
pAlloc->flags = 0;
return HB_MEM_PTR( pAlloc ); /* hide the internal data */
}
else
return NULL;
}
| garbage.c | 163 |
VOID | hb_gcFree( void *pBlock )
void hb_gcFree( void *pBlock )
{
if( pBlock )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pBlock );
if( !( pAlloc->used & HB_GC_DELETE ) )
{
/* Don't release the block that will be deleted during finalization */
if( pAlloc->locked )
hb_gcUnlink( &s_pLockedBlock, pAlloc );
else
hb_gcUnlink( &s_pCurrBlock, pAlloc );
if( pAlloc->flags & HB_GC_USERSWEEP )
hb_gcUnregisterSweep( pBlock );
HB_GARBAGE_FREE( pAlloc );
}
}
else
{
hb_errInternal( HB_EI_XFREENULL, NULL, NULL, NULL );
}
}
| garbage.c | 182 |
HB_GARBAGE_FUNC_PTR | hb_gcFunc( void *pBlock )
HB_GARBAGE_FUNC_PTR hb_gcFunc( void *pBlock )
{
return HB_GC_PTR( pBlock )->pFunc;
}
| garbage.c | 209 |
VOID | hb_gcRefInc( void * pBlock )
void hb_gcRefInc( void * pBlock )
{
hb_xRefInc( HB_GC_PTR( pBlock ) );
}
| garbage.c | 217 |
BOOL | hb_gcRefDec( void * pBlock )
BOOL hb_gcRefDec( void * pBlock )
{
return hb_xRefDec( HB_GC_PTR( pBlock ) );
}
| garbage.c | 224 |
VOID | hb_gcRefFree( void * pBlock )
void hb_gcRefFree( void * pBlock )
{
if( pBlock )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pBlock );
if( hb_xRefDec( pAlloc ) )
{
/* Don't release the block that will be deleted during finalization */
if( !( pAlloc->used & HB_GC_DELETE ) )
{
/* unlink the block first to avoid possible problems
* if cleanup function activate GC
*/
if( pAlloc->locked )
hb_gcUnlink( &s_pLockedBlock, pAlloc );
else
hb_gcUnlink( &s_pCurrBlock, pAlloc );
pAlloc->used |= HB_GC_DELETE;
/* execute clean-up function */
if( pAlloc->pFunc )
( pAlloc->pFunc )( pBlock );
if( pAlloc->used & HB_GC_DELETE )
HB_GARBAGE_FREE( pAlloc );
}
}
}
else
{
hb_errInternal( HB_EI_XFREENULL, NULL, NULL, NULL );
}
}
| garbage.c | 231 |
HB_COUNTER | hb_gcRefCount( void * pBlock )
HB_COUNTER hb_gcRefCount( void * pBlock )
{
return hb_xRefCount( HB_GC_PTR( pBlock ) );
}
| garbage.c | 270 |
VOID | hb_gcRefCheck( void * pBlock )
void hb_gcRefCheck( void * pBlock )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pBlock );
if( !( pAlloc->used & HB_GC_DELETELST ) )
{
if( hb_xRefCount( pAlloc ) != 0 )
{
if( hb_vmRequestQuery() == 0 )
hb_errRT_BASE( EG_DESTRUCTOR, 1301, NULL, "Reference to freed block", 0 );
hb_gcLink( &s_pCurrBlock, pAlloc );
pAlloc->used = s_uUsedFlag;
}
}
}
| garbage.c | 276 |
STATIC HB_GARBAGE_FUNC( | hb_gcGripRelease )
static HB_GARBAGE_FUNC( hb_gcGripRelease )
{
/* Item was already released in hb_gcGripDrop() - then we have nothing
* to do here
*/
HB_SYMBOL_UNUSED( Cargo );
}
| garbage.c | 297 |
HB_ITEM_PTR | hb_gcGripGet( HB_ITEM_PTR pOrigin )
HB_ITEM_PTR hb_gcGripGet( HB_ITEM_PTR pOrigin )
{
HB_GARBAGE_PTR pAlloc;
pAlloc = HB_GARBAGE_NEW( sizeof( HB_ITEM ) );
if( pAlloc )
{
HB_ITEM_PTR pItem = ( HB_ITEM_PTR ) HB_MEM_PTR( pAlloc );
hb_gcLink( &s_pLockedBlock, pAlloc );
pAlloc->pFunc = hb_gcGripRelease;
pAlloc->locked = 1;
pAlloc->used = s_uUsedFlag;
pAlloc->flags = 0;
pItem->type = HB_IT_NIL;
if( pOrigin )
hb_itemCopy( pItem, pOrigin );
return pItem;
}
else
return NULL;
}
| garbage.c | 305 |
VOID | hb_gcGripDrop( HB_ITEM_PTR pItem )
void hb_gcGripDrop( HB_ITEM_PTR pItem )
{
if( pItem )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pItem );
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem ); /* clear value stored in this item */
hb_gcUnlink( &s_pLockedBlock, pAlloc );
HB_GARBAGE_FREE( pAlloc );
}
}
| garbage.c | 330 |
VOID * | hb_gcLock( void * pBlock )
void * hb_gcLock( void * pBlock )
{
if( pBlock )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pBlock );
if( ! pAlloc->locked )
{
hb_gcUnlink( &s_pCurrBlock, pAlloc );
hb_gcLink( &s_pLockedBlock, pAlloc );
}
++pAlloc->locked;
}
return pBlock;
}
| garbage.c | 344 |
VOID * | hb_gcUnlock( void * pBlock )
void * hb_gcUnlock( void * pBlock )
{
if( pBlock )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pBlock );
if( pAlloc->locked )
{
if( --pAlloc->locked == 0 )
{
hb_gcUnlink( &s_pLockedBlock, pAlloc );
hb_gcLink( &s_pCurrBlock, pAlloc );
pAlloc->used = s_uUsedFlag;
}
}
}
return pBlock;
}
| garbage.c | 364 |
VOID | hb_gcItemRef( HB_ITEM_PTR pItem )
void hb_gcItemRef( HB_ITEM_PTR pItem )
{
while( HB_IS_BYREF( pItem ) )
{
if( HB_IS_ENUM( pItem ) )
return;
else if( HB_IS_EXTREF( pItem ) )
{
pItem->item.asExtRef.func->mark( pItem->item.asExtRef.value );
return;
}
else if( ! HB_IS_MEMVAR( pItem ) &&
pItem->item.asRefer.offset == 0 &&
pItem->item.asRefer.value >= 0 )
{
/* array item reference */
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pItem->item.asRefer.BasePtr.array );
if( pAlloc->used == s_uUsedFlag )
{
ULONG ulSize = pItem->item.asRefer.BasePtr.array->ulLen;
pAlloc->used ^= HB_GC_USED_FLAG;
pItem = pItem->item.asRefer.BasePtr.array->pItems;
while( ulSize )
{
hb_gcItemRef( pItem++ );
--ulSize;
}
}
return;
}
pItem = hb_itemUnRefOnce( pItem );
}
if( HB_IS_ARRAY( pItem ) )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pItem->item.asArray.value );
/* Check this array only if it was not checked yet */
if( pAlloc->used == s_uUsedFlag )
{
ULONG ulSize = pItem->item.asArray.value->ulLen;
/* mark this block as used so it will be no re-checked from
* other references
*/
pAlloc->used ^= HB_GC_USED_FLAG;
/* mark also all array elements */
pItem = pItem->item.asArray.value->pItems;
while( ulSize )
{
hb_gcItemRef( pItem++ );
--ulSize;
}
}
}
else if( HB_IS_HASH( pItem ) )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pItem->item.asHash.value );
/* Check this hash table only if it was not checked yet */
if( pAlloc->used == s_uUsedFlag )
{
/* mark this block as used so it will be no re-checked from
* other references
*/
pAlloc->used ^= HB_GC_USED_FLAG;
/* mark also all hash elements */
hb_hashRefGrabage( pItem );
}
}
else if( HB_IS_BLOCK( pItem ) )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pItem->item.asBlock.value );
if( pAlloc->used == s_uUsedFlag )
{
HB_CODEBLOCK_PTR pCBlock = pItem->item.asBlock.value;
USHORT ui = 1;
pAlloc->used ^= HB_GC_USED_FLAG; /* mark this codeblock as used */
/* mark as used all detached variables in a codeblock */
while( ui <= pCBlock->uiLocals )
{
hb_gcItemRef( &pCBlock->pLocals[ ui++ ] );
}
}
}
else if( HB_IS_POINTER( pItem ) )
{
if( pItem->item.asPointer.collect )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pItem->item.asPointer.value );
if( pAlloc->used == s_uUsedFlag )
{
if( ! (pAlloc->flags & HB_GC_USERSWEEP) )
{
/* Mark this pointer as used only if it doesn't have
registerd his own sweeper function that checks if
this pointer is still used.
The sweeper function will be called elsewhere.
*/
pAlloc->used ^= HB_GC_USED_FLAG; /* mark this codeblock as used */
}
}
}
}
/* all other data types don't need the GC */
}
| garbage.c | 386 |
VOID | hb_gcRegisterSweep( HB_GARBAGE_SWEEPER_PTR pSweep, void * Cargo )
void hb_gcRegisterSweep( HB_GARBAGE_SWEEPER_PTR pSweep, void * Cargo )
{
HB_GARBAGE_EXTERN_PTR pExt;
pExt = ( HB_GARBAGE_EXTERN_PTR ) hb_xgrab( sizeof( HB_GARBAGE_EXTERN ) );
pExt->pFunc = pSweep;
pExt->pBlock = Cargo;
pExt->pNext = s_pSweepExtern;
s_pSweepExtern = pExt;
/* set user sweep flag */
HB_GC_PTR( Cargo )->flags ^= HB_GC_USERSWEEP;
}
| garbage.c | 500 |
STATIC VOID | hb_gcUnregisterSweep( void * Cargo )
static void hb_gcUnregisterSweep( void * Cargo )
{
HB_GARBAGE_EXTERN_PTR pExt;
HB_GARBAGE_EXTERN_PTR pPrev;
pPrev = pExt = s_pSweepExtern;
while( pExt )
{
if( pExt->pBlock == Cargo )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( Cargo );
/* clear user sweep flag */
pAlloc->flags &= ~ HB_GC_USERSWEEP;
if( pExt == s_pSweepExtern )
{
s_pSweepExtern = pExt->pNext;
}
else
{
pPrev->pNext = pExt->pNext;
}
hb_xfree( (void *) pExt );
pExt = NULL;
}
else
{
pPrev = pExt;
pExt = pExt->pNext;
}
}
}
| garbage.c | 520 |
VOID | hb_gcCollect( void )
void hb_gcCollect( void )
{
/* TODO: decrease the amount of time spend collecting */
hb_gcCollectAll();
}
| garbage.c | 555 |
VOID | hb_gcCollectAll( void )
void hb_gcCollectAll( void )
{
if( s_pCurrBlock && !s_bCollecting )
{
HB_GARBAGE_PTR pAlloc, pDelete;
s_bCollecting = TRUE;
/* Step 1 - mark */
/* All blocks are already marked because we are flipping
* the used/unused flag
*/
/* Step 2 - sweep */
/* check all known places for blocks they are referring */
hb_vmIsLocalRef();
hb_vmIsStaticRef();
hb_memvarsIsMemvarRef();
hb_gcItemRef( hb_stackReturnItem() );
hb_clsIsClassRef();
if( s_pSweepExtern )
{
HB_GARBAGE_EXTERN_PTR *pExtPtr = &s_pSweepExtern;
do
{
pAlloc = HB_GC_PTR( ( *pExtPtr )->pBlock );
if( ( ( *pExtPtr )->pFunc )( ( *pExtPtr )->pBlock ) )
{
/* block is still used */
pAlloc->used ^= HB_GC_USED_FLAG;
pExtPtr = &( *pExtPtr )->pNext;
}
else
{
HB_GARBAGE_EXTERN_PTR pFree = *pExtPtr;
pAlloc->flags &= ~ HB_GC_USERSWEEP;
*pExtPtr = ( *pExtPtr )->pNext;
hb_xfree( pFree );
}
}
while( *pExtPtr );
}
/* check list of locked block for blocks referenced from
* locked block
*/
if( s_pLockedBlock )
{
pAlloc = s_pLockedBlock;
do
{ /* it is not very elegant method but it works well */
if( pAlloc->pFunc == hb_gcGripRelease )
{
hb_gcItemRef( ( HB_ITEM_PTR ) HB_MEM_PTR( pAlloc ) );
}
pAlloc = pAlloc->pNext;
} while( s_pLockedBlock != pAlloc );
}
/* Step 3 - finalize */
/* Release all blocks that are still marked as unused */
/*
* infinite loop can appear when we are executing clean-up functions
* scanning s_pCurrBlock. It's possible that one of them will free
* the GC block which we are using as stop condition. Only blocks
* for which we set HB_GC_DELETE flag are guarded against releasing.
* To avoid such situation first we are moving blocks which will be
* deleted to separate list. It's additional operation but it can
* even increase the speed when we are deleting only few percent
* of all allocated blocks because in next passes we will scan only
* deleted block list. [druzus]
*/
pAlloc = NULL; /* for stop condition */
do
{
if( s_pCurrBlock->used == s_uUsedFlag )
{
pDelete = s_pCurrBlock;
s_pCurrBlock->used |= HB_GC_DELETE | HB_GC_DELETELST;
hb_gcUnlink( &s_pCurrBlock, s_pCurrBlock );
hb_gcLink( &s_pDeletedBlock, pDelete );
}
else
{
/* at least one block will not be deleted, set new stop condition */
if( ! pAlloc )
pAlloc = s_pCurrBlock;
s_pCurrBlock = s_pCurrBlock->pNext;
}
} while( pAlloc != s_pCurrBlock );
/* do we have any deleted blocks? */
if( s_pDeletedBlock )
{
/* call a cleanup function */
pAlloc = s_pDeletedBlock;
do
{
if( s_pDeletedBlock->pFunc )
( s_pDeletedBlock->pFunc )( HB_MEM_PTR( s_pDeletedBlock ) );
s_pDeletedBlock = s_pDeletedBlock->pNext;
} while( pAlloc != s_pDeletedBlock );
/* release all deleted blocks */
do
{
pDelete = s_pDeletedBlock;
hb_gcUnlink( &s_pDeletedBlock, s_pDeletedBlock );
if( hb_xRefCount( pDelete ) != 0 )
{
if( hb_vmRequestQuery() == 0 )
hb_errRT_BASE( EG_DESTRUCTOR, 1301, NULL, "Reference to freed block", 0 );
hb_gcLink( &s_pCurrBlock, pAlloc );
pAlloc->used = s_uUsedFlag;
}
else
HB_GARBAGE_FREE( pDelete );
} while( s_pDeletedBlock );
}
/* Step 4 - flip flag */
/* Reverse used/unused flag so we don't have to mark all blocks
* during next collecting
*/
s_uUsedFlag ^= HB_GC_USED_FLAG;
s_bCollecting = FALSE;
}
}
| garbage.c | 561 |
VOID | hb_gcReleaseAll( void )
void hb_gcReleaseAll( void )
{
if( s_pCurrBlock )
{
HB_GARBAGE_PTR pAlloc, pDelete;
s_bCollecting = TRUE;
pAlloc = s_pCurrBlock;
do
{
/* call a cleanup function */
if( s_pCurrBlock->pFunc )
{
HB_TRACE( HB_TR_INFO, ( "Cleanup, %p", s_pCurrBlock ) );
s_pCurrBlock->used |= HB_GC_DELETE | HB_GC_DELETELST;
( s_pCurrBlock->pFunc )( HB_MEM_PTR( s_pCurrBlock ) );
}
s_pCurrBlock = s_pCurrBlock->pNext;
} while ( s_pCurrBlock && pAlloc != s_pCurrBlock );
do
{
HB_TRACE( HB_TR_INFO, ( "Release %p", s_pCurrBlock ) );
pDelete = s_pCurrBlock;
hb_gcUnlink( &s_pCurrBlock, s_pCurrBlock );
HB_GARBAGE_FREE( pDelete );
} while ( s_pCurrBlock );
}
s_bCollecting = FALSE;
}
| garbage.c | 704 |
HB_FUNC | HB_GCSTEP(void)
HB_FUNC( HB_GCSTEP )
{
hb_gcCollect();
}
| garbage.c | 741 |
HB_FUNC | HB_GCALL(void)
HB_FUNC( HB_GCALL )
{
/* call hb_ret() to clear stack return item, HVM does not clean
* it before calling functions/procedures if caller does not
* try to retrieve returned value. It's safe and cost nearly
* nothing in whole GC scan process. It may help when previously
* called function returned complex item with cross references.
* It's quite common situation that people executes HB_GCALL()
* immediately after such function. [druzus]
*/
hb_ret();
hb_gcCollectAll();
}
| garbage.c | 749 |
hashes.c |
Type | Function | Source | Line |
VOID | hb_hashRefGrabage( PHB_ITEM pHash )
void hb_hashRefGrabage( PHB_ITEM pHash )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashRefGrabage(%p)", pHash));
if( HB_IS_HASH( pHash ) && pHash->item.asHash.value->ulLen > 0 )
{
PHB_HASHPAIR pPairs = pHash->item.asHash.value->pPairs;
ULONG ulLen = pHash->item.asHash.value->ulLen;
while( ulLen-- )
{
if( HB_IS_GCITEM( &pPairs[ ulLen ].key ) )
hb_gcItemRef( &pPairs[ ulLen ].key );
if( HB_IS_GCITEM( &pPairs[ ulLen ].value ) )
hb_gcItemRef( &pPairs[ ulLen ].value );
}
}
}
| hashes.c | 83 |
STATIC HB_GARBAGE_FUNC( | hb_hashReleaseGarbage )
static HB_GARBAGE_FUNC( hb_hashReleaseGarbage )
{
PHB_BASEHASH pBaseHash = ( PHB_BASEHASH ) Cargo;
HB_TRACE(HB_TR_INFO, ("hb_hashReleaseGarbage(%p)", pBaseHash ));
if( pBaseHash->ulSize > 0 )
{
PHB_HASHPAIR pPairs = pBaseHash->pPairs;
ULONG ulLen = pBaseHash->ulLen;
/*
* clear the pBaseHash->pPairs to avoid infinite loop in cross
* referenced items when pBaseArray is not freed due to buggy
* object destructor [druzus]
*/
pBaseHash->pPairs = NULL;
pBaseHash->ulLen = 0;
while( ulLen-- )
{
if( HB_IS_COMPLEX( &pPairs[ ulLen ].key ) )
hb_itemClear( &pPairs[ ulLen ].key );
if( HB_IS_COMPLEX( &pPairs[ ulLen ].value ) )
hb_itemClear( &pPairs[ ulLen ].value );
}
hb_xfree( pPairs );
}
if( pBaseHash->pDefault )
{
PHB_ITEM pDefault = pBaseHash->pDefault;
pBaseHash->pDefault = NULL;
hb_itemRelease( pDefault );
}
}
| hashes.c | 102 |
STATIC INT | hb_hashItemCmp( PHB_ITEM pKey1, PHB_ITEM pKey2, BOOL fIgnoreCase )
static int hb_hashItemCmp( PHB_ITEM pKey1, PHB_ITEM pKey2, BOOL fIgnoreCase )
{
if( HB_IS_STRING( pKey1 ) )
{
if( HB_IS_STRING( pKey2 ) )
{
if( fIgnoreCase )
return hb_itemStrICmp( pKey1, pKey2, TRUE );
else
return hb_itemStrCmp( pKey1, pKey2, TRUE );
}
else
return 1;
}
else if( HB_IS_DATE( pKey1 ) )
{
if( HB_IS_DATE( pKey2 ) )
return pKey1->item.asDate.value < pKey2->item.asDate.value ? -1 :
( pKey1->item.asDate.value > pKey2->item.asDate.value ? 1 : 0 );
else if( HB_IS_STRING( pKey2 ) )
return -1;
else
return 1;
}
else if( HB_IS_POINTER( pKey1 ) )
{
if( HB_IS_POINTER( pKey2 ) )
return pKey1->item.asPointer.value < pKey2->item.asPointer.value ? -1 :
( pKey1->item.asPointer.value > pKey2->item.asPointer.value ? 1 : 0 );
else if( HB_IS_STRING( pKey2 ) || HB_IS_DATE( pKey2 ) )
return -1;
else
return 1;
}
else if( HB_IS_NUMINT( pKey1 ) && HB_IS_NUMINT( pKey2 ) )
{
HB_LONG l1 = HB_ITEM_GET_NUMINTRAW( pKey1 ),
l2 = HB_ITEM_GET_NUMINTRAW( pKey2 );
return l1 < l2 ? -1 : ( l1 > l2 ? 1 : 0 );
}
else if( HB_IS_NUMERIC( pKey2 ) )
{
double d1 = hb_itemGetND( pKey1 ), d2 = hb_itemGetND( pKey2 );
return d1 < d2 ? -1 : ( d1 > d2 ? 1 : 0 );
}
return -1;
}
| hashes.c | 139 |
STATIC BOOL | hb_hashFind( PHB_BASEHASH pBaseHash, PHB_ITEM pKey, ULONG * pulPos )
static BOOL hb_hashFind( PHB_BASEHASH pBaseHash, PHB_ITEM pKey, ULONG * pulPos )
{
ULONG ulLeft = 0, ulRight = pBaseHash->ulLen, ulMiddle;
BOOL fIgnoreCase = ( pBaseHash->iFlags & HB_HASH_IGNORECASE ) != 0;
int i;
while( ulLeft < ulRight )
{
ulMiddle = ( ulLeft + ulRight ) >> 1;
i = hb_hashItemCmp( &pBaseHash->pPairs[ ulMiddle ].key, pKey, fIgnoreCase );
if( i == 0 )
{
if( pulPos )
*pulPos = ulMiddle;
return TRUE;
}
else if( i < 0 )
ulLeft = ulMiddle + 1;
else
ulRight = ulMiddle;
}
if( pulPos )
*pulPos = ulLeft;
return FALSE;
}
| hashes.c | 187 |
STATIC VOID | hb_hashResize( PHB_BASEHASH pBaseHash, ULONG ulNewSize )
static void hb_hashResize( PHB_BASEHASH pBaseHash, ULONG ulNewSize )
{
if( pBaseHash->ulSize < ulNewSize )
{
if( pBaseHash->ulSize )
pBaseHash->pPairs = ( PHB_HASHPAIR ) hb_xrealloc( pBaseHash->pPairs,
ulNewSize * sizeof( HB_HASHPAIR ) );
else
pBaseHash->pPairs = ( PHB_HASHPAIR ) hb_xgrab( ulNewSize * sizeof( HB_HASHPAIR ) );
do
{
pBaseHash->pPairs[ pBaseHash->ulSize ].key.type = HB_IT_NIL;
pBaseHash->pPairs[ pBaseHash->ulSize ].value.type = HB_IT_NIL;
}
while( ++pBaseHash->ulSize < ulNewSize );
}
else if( pBaseHash->ulSize > ulNewSize && pBaseHash->ulLen <= ulNewSize )
{
pBaseHash->ulSize = ulNewSize;
if( ulNewSize )
pBaseHash->pPairs = ( PHB_HASHPAIR ) hb_xrealloc( pBaseHash->pPairs,
ulNewSize * sizeof( HB_HASHPAIR ) );
else
{
hb_xfree( pBaseHash->pPairs );
pBaseHash->pPairs = NULL;
}
}
}
| hashes.c | 214 |
STATIC PHB_ITEM | hb_hashValuePtr( PHB_BASEHASH pBaseHash, PHB_ITEM pKey, BOOL fAdd )
static PHB_ITEM hb_hashValuePtr( PHB_BASEHASH pBaseHash, PHB_ITEM pKey, BOOL fAdd )
{
ULONG ulPos;
if( !hb_hashFind( pBaseHash, pKey, &ulPos ) )
{
if( !fAdd )
return NULL;
if( pBaseHash->ulSize == pBaseHash->ulLen )
hb_hashResize( pBaseHash, pBaseHash->ulSize + HB_HASH_ITEM_ALLOC );
if( ulPos < pBaseHash->ulLen )
{
memmove( pBaseHash->pPairs + ulPos + 1, pBaseHash->pPairs + ulPos,
( pBaseHash->ulLen - ulPos ) * sizeof( HB_HASHPAIR ) );
pBaseHash->pPairs[ ulPos ].key.type = HB_IT_NIL;
pBaseHash->pPairs[ ulPos ].value.type = HB_IT_NIL;
}
hb_itemCopy( &pBaseHash->pPairs[ ulPos ].key, pKey );
pBaseHash->ulLen++;
if( pBaseHash->pDefault )
{
PHB_ITEM pDefault = hb_itemClone( pBaseHash->pDefault );
hb_itemMove( &pBaseHash->pPairs[ ulPos ].value, pDefault );
hb_itemRelease( pDefault );
}
}
return &pBaseHash->pPairs[ ulPos ].value;
}
| hashes.c | 245 |
STATIC VOID | hb_hashDelPair( PHB_BASEHASH pBaseHash, ULONG ulPos )
static void hb_hashDelPair( PHB_BASEHASH pBaseHash, ULONG ulPos )
{
if( --pBaseHash->ulLen == 0 )
{
PHB_HASHPAIR pPairs = pBaseHash->pPairs;
pBaseHash->pPairs = NULL;
pBaseHash->ulSize = 0;
if( HB_IS_COMPLEX( &pPairs->key ) )
hb_itemClear( &pPairs->key );
if( HB_IS_COMPLEX( &pPairs->value ) )
hb_itemClear( &pPairs->value );
hb_xfree( pPairs );
}
else if( ulPos == pBaseHash->ulLen )
{
hb_itemSetNil( &pBaseHash->pPairs[ ulPos ].key );
hb_itemSetNil( &pBaseHash->pPairs[ ulPos ].value );
}
else
{
HB_HASHPAIR pair;
memcpy( &pair, pBaseHash->pPairs + ulPos, sizeof( HB_HASHPAIR ) );
memmove( pBaseHash->pPairs + ulPos, pBaseHash->pPairs + ulPos + 1,
( pBaseHash->ulLen - ulPos ) * sizeof( HB_HASHPAIR ) );
pBaseHash->pPairs[ pBaseHash->ulLen ].key.type = HB_IT_NIL;
pBaseHash->pPairs[ pBaseHash->ulLen ].value.type = HB_IT_NIL;
if( HB_IS_COMPLEX( &pair.key ) )
hb_itemClear( &pair.key );
if( HB_IS_COMPLEX( &pair.value ) )
hb_itemClear( &pair.value );
if( pBaseHash->ulSize - pBaseHash->ulLen > ( HB_HASH_ITEM_ALLOC << 1 ) )
{
pBaseHash->ulSize -= HB_HASH_ITEM_ALLOC;
pBaseHash->pPairs = ( PHB_HASHPAIR ) hb_xrealloc( pBaseHash->pPairs,
pBaseHash->ulSize * sizeof( HB_HASHPAIR ) );
}
}
}
| hashes.c | 277 |
HB_EXPORT PHB_ITEM | hb_hashNew( PHB_ITEM pItem )
HB_EXPORT PHB_ITEM hb_hashNew( PHB_ITEM pItem )
{
PHB_BASEHASH pBaseHash;
HB_TRACE(HB_TR_DEBUG, ("hb_hashNew(%p)", pItem));
if( pItem == NULL )
pItem = hb_itemNew( NULL );
else if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
pBaseHash = ( PHB_BASEHASH ) hb_gcAlloc( sizeof( HB_BASEHASH ), hb_hashReleaseGarbage );
pBaseHash->pPairs = NULL;
pBaseHash->ulSize = 0;
pBaseHash->ulLen = 0;
pBaseHash->iFlags = HB_HASH_AUTOADD_ASSIGN;
pBaseHash->pDefault = NULL;
pItem->type = HB_IT_HASH;
pItem->item.asHash.value = pBaseHash;
return pItem;
}
| hashes.c | 316 |
HB_EXPORT ULONG | hb_hashLen( PHB_ITEM pHash )
HB_EXPORT ULONG hb_hashLen( PHB_ITEM pHash )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashLen(%p)", pHash));
if( HB_IS_HASH( pHash ) )
return pHash->item.asHash.value->ulLen;
else
return 0;
}
| hashes.c | 340 |
HB_EXPORT VOID | hb_hashPreallocate( PHB_ITEM pHash, ULONG ulNewSize )
HB_EXPORT void hb_hashPreallocate( PHB_ITEM pHash, ULONG ulNewSize )
{
if( HB_IS_HASH( pHash ) )
hb_hashResize( pHash->item.asHash.value, ulNewSize );
}
| hashes.c | 350 |
HB_EXPORT PHB_ITEM | hb_hashGetItemPtr( PHB_ITEM pHash, PHB_ITEM pKey, int iFlags )
HB_EXPORT PHB_ITEM hb_hashGetItemPtr( PHB_ITEM pHash, PHB_ITEM pKey, int iFlags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetItemPtr(%p,%p,%d)", pHash, pKey, iFlags));
if( HB_IS_HASH( pHash ) && HB_IS_HASHKEY( pKey ) )
{
PHB_ITEM pDest = hb_hashValuePtr( pHash->item.asHash.value, pKey,
iFlags && ( pHash->item.asHash.value->iFlags & iFlags ) == iFlags );
if( pDest )
return HB_IS_BYREF( pDest ) ? hb_itemUnRef( pDest ) : pDest;
}
return NULL;
}
| hashes.c | 356 |
HB_EXPORT PHB_ITEM | hb_hashGetItemRefPtr( PHB_ITEM pHash, PHB_ITEM pKey )
HB_EXPORT PHB_ITEM hb_hashGetItemRefPtr( PHB_ITEM pHash, PHB_ITEM pKey )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetItemRefPtr(%p,%p)", pHash, pKey));
if( HB_IS_HASH( pHash ) && HB_IS_HASHKEY( pKey ) )
{
PHB_ITEM pDest = hb_hashValuePtr( pHash->item.asHash.value, pKey,
( pHash->item.asHash.value->iFlags & HB_HASH_AUTOADD_REFERENCE ) ==
HB_HASH_AUTOADD_REFERENCE );
if( pDest )
{
if( !HB_IS_BYREF( pDest ) )
pDest = hb_memvarDetachLocal( pDest );
return pDest;
}
}
return NULL;
}
| hashes.c | 371 |
HB_EXPORT BOOL | hb_hashScan( PHB_ITEM pHash, PHB_ITEM pKey, ULONG * pulPos )
HB_EXPORT BOOL hb_hashScan( PHB_ITEM pHash, PHB_ITEM pKey, ULONG * pulPos )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashScan(%p,%p,%p)", pHash, pKey, pulPos));
if( HB_IS_HASH( pHash ) )
{
ULONG ulPos;
if( HB_IS_HASHKEY( pKey ) )
{
if( hb_hashFind( pHash->item.asHash.value, pKey, &ulPos ) )
{
if( pulPos )
*pulPos = ulPos + 1;
return TRUE;
}
}
else if( HB_IS_HASH( pKey ) && pKey->item.asHash.value->ulLen == 1 )
{
if( hb_hashFind( pHash->item.asHash.value, &pKey->item.asHash.value->pPairs[ 0 ].key, &ulPos ) )
{
PHB_ITEM pVal1 = &pHash->item.asHash.value->pPairs[ ulPos ].value;
PHB_ITEM pVal2 = &pKey->item.asHash.value->pPairs[ 0 ].value;
BOOL fResult = FALSE;
if( HB_IS_STRING( pVal1 ) && HB_IS_STRING( pVal2 ) )
fResult = hb_itemStrCmp( pVal1, pVal2, TRUE ) == 0;
else if( HB_IS_NUMINT( pVal1 ) && HB_IS_NUMINT( pVal2 ) )
fResult = HB_ITEM_GET_NUMINTRAW( pVal1 ) == HB_ITEM_GET_NUMINTRAW( pVal2 );
else if( HB_IS_NUMERIC( pVal1 ) && HB_IS_NUMERIC( pVal2 ) )
fResult = hb_itemGetND( pVal1 ) == hb_itemGetND( pVal2 );
else if( HB_IS_NIL( pVal1 ) && HB_IS_NIL( pVal2 ) )
fResult = TRUE;
else if( hb_itemType( pVal1 ) & hb_itemType( pVal2 ) )
{
hb_vmPush( pVal1 );
hb_vmPush( pVal2 );
if( !hb_xvmExactlyEqual() )
{
fResult = hb_itemGetL( hb_stackItemFromTop( -1 ) );
hb_stackPop();
}
}
if( fResult )
{
if( pulPos )
*pulPos = ulPos + 1;
return TRUE;
}
}
}
}
if( pulPos )
*pulPos = 0;
return FALSE;
}
| hashes.c | 391 |
HB_EXPORT BOOL | hb_hashClear( PHB_ITEM pHash )
HB_EXPORT BOOL hb_hashClear( PHB_ITEM pHash )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashClear(%p)", pHash));
if( HB_IS_HASH( pHash ) )
{
if( pHash->item.asHash.value->ulSize )
{
while( pHash->item.asHash.value->ulLen )
{
pHash->item.asHash.value->ulLen--;
if( HB_IS_COMPLEX( &pHash->item.asHash.value->pPairs[ pHash->item.asHash.value->ulLen ].key ) )
hb_itemClear( &pHash->item.asHash.value->pPairs[ pHash->item.asHash.value->ulLen ].key );
if( HB_IS_COMPLEX( &pHash->item.asHash.value->pPairs[ pHash->item.asHash.value->ulLen ].value ) )
hb_itemClear( &pHash->item.asHash.value->pPairs[ pHash->item.asHash.value->ulLen ].value );
}
/*
* This condition is a protection against recursive call
* from .prg object destructor [druzus]
*/
if( pHash->item.asHash.value->ulSize )
{
hb_xfree( pHash->item.asHash.value->pPairs );
pHash->item.asHash.value->pPairs = NULL;
pHash->item.asHash.value->ulSize = 0;
}
}
return TRUE;
}
return FALSE;
}
| hashes.c | 446 |
HB_EXPORT BOOL | hb_hashDel( PHB_ITEM pHash, PHB_ITEM pKey )
HB_EXPORT BOOL hb_hashDel( PHB_ITEM pHash, PHB_ITEM pKey )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashDel(%p,%p)", pHash, pKey));
if( HB_IS_HASH( pHash ) && HB_IS_HASHKEY( pKey ) )
{
PHB_BASEHASH pBaseHash = pHash->item.asHash.value;
ULONG ulPos;
if( hb_hashFind( pBaseHash, pKey, &ulPos ) )
{
hb_hashDelPair( pBaseHash, ulPos );
return TRUE;
}
}
return FALSE;
}
| hashes.c | 479 |
HB_EXPORT BOOL | hb_hashRemove( PHB_ITEM pHash, PHB_ITEM pItem )
HB_EXPORT BOOL hb_hashRemove( PHB_ITEM pHash, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashRemove(%p,%p)", pHash, pItem));
if( HB_IS_HASH( pHash ) )
{
if( HB_IS_HASHKEY( pItem ) )
{
hb_hashDel( pHash, pItem );
return TRUE;
}
else if( HB_IS_ARRAY( pItem ) )
{
ULONG ul = 0;
PHB_ITEM pKey;
while( ( pKey = hb_arrayGetItemPtr( pItem, ++ul ) ) != NULL )
hb_hashDel( pHash, pKey );
return TRUE;
}
else if( HB_IS_HASH( pItem ) )
{
if( pHash->item.asHash.value == pItem->item.asHash.value )
hb_hashClear( pHash );
else
{
ULONG ulLen = 0;
while( ulLen < pItem->item.asHash.value->ulLen )
hb_hashDel( pHash, &pItem->item.asHash.value->pPairs[ ulLen++ ].key );
}
return TRUE;
}
}
return FALSE;
}
| hashes.c | 498 |
HB_EXPORT BOOL | hb_hashAdd( PHB_ITEM pHash, PHB_ITEM pKey, PHB_ITEM pValue )
HB_EXPORT BOOL hb_hashAdd( PHB_ITEM pHash, PHB_ITEM pKey, PHB_ITEM pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashAdd(%p,%p,%p)", pHash, pKey, pValue));
if( HB_IS_HASH( pHash ) && HB_IS_HASHKEY( pKey ) )
{
PHB_ITEM pDest = hb_hashValuePtr( pHash->item.asHash.value, pKey, TRUE );
if( pDest )
{
if( HB_IS_BYREF( pDest ) )
pDest = hb_itemUnRef( pDest );
if( pValue )
hb_itemCopyFromRef( pDest, pValue );
else
hb_itemSetNil( pDest );
return TRUE;
}
}
return FALSE;
}
| hashes.c | 533 |
HB_EXPORT PHB_ITEM | hb_hashGetKeyAt( PHB_ITEM pHash, ULONG ulPos )
HB_EXPORT PHB_ITEM hb_hashGetKeyAt( PHB_ITEM pHash, ULONG ulPos )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetKeyAt(%p,%lu)", pHash, ulPos));
if( HB_IS_HASH( pHash ) && ulPos > 0 && ulPos <= pHash->item.asHash.value->ulLen )
return &pHash->item.asHash.value->pPairs[ ulPos - 1 ].key;
else
return NULL;
}
| hashes.c | 555 |
HB_EXPORT PHB_ITEM | hb_hashGetValueAt( PHB_ITEM pHash, ULONG ulPos )
HB_EXPORT PHB_ITEM hb_hashGetValueAt( PHB_ITEM pHash, ULONG ulPos )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetValueAt(%p,%lu)", pHash, ulPos));
if( HB_IS_HASH( pHash ) && ulPos > 0 && ulPos <= pHash->item.asHash.value->ulLen )
return HB_IS_BYREF( &pHash->item.asHash.value->pPairs[ ulPos - 1 ].value ) ?
hb_itemUnRef( &pHash->item.asHash.value->pPairs[ ulPos - 1 ].value ) :
&pHash->item.asHash.value->pPairs[ ulPos - 1 ].value;
else
return NULL;
}
| hashes.c | 565 |
HB_EXPORT BOOL | hb_hashDelAt( PHB_ITEM pHash, ULONG ulPos )
HB_EXPORT BOOL hb_hashDelAt( PHB_ITEM pHash, ULONG ulPos )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashDelAt(%p,%lu)", pHash, ulPos));
if( HB_IS_HASH( pHash ) && ulPos > 0 && ulPos <= pHash->item.asHash.value->ulLen )
{
hb_hashDelPair( pHash->item.asHash.value, ulPos - 1 );
return TRUE;
}
else
return FALSE;
}
| hashes.c | 577 |
HB_EXPORT VOID * | hb_hashId( PHB_ITEM pHash )
HB_EXPORT void * hb_hashId( PHB_ITEM pHash )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashId(%p)", pHash));
if( HB_IS_HASH( pHash ) )
return ( void * ) pHash->item.asHash.value;
else
return NULL;
}
| hashes.c | 590 |
VOID | hb_hashCloneBody( PHB_ITEM pHash, PHB_ITEM pDest, PHB_NESTED_CLONED pClonedList )
void hb_hashCloneBody( PHB_ITEM pHash, PHB_ITEM pDest, PHB_NESTED_CLONED pClonedList )
{
ULONG ulPos;
HB_TRACE(HB_TR_DEBUG, ("hb_hashCloneBody(%p,%p,%p)", pHash, pDest, pClonedList));
hb_hashNew( pDest );
hb_hashResize( pDest->item.asHash.value, pHash->item.asHash.value->ulSize );
pDest->item.asHash.value->iFlags = pHash->item.asHash.value->iFlags;
if( pHash->item.asHash.value->pDefault )
pDest->item.asHash.value->pDefault =
hb_itemNew( pHash->item.asHash.value->pDefault );
for( ulPos = 0; ulPos < pHash->item.asHash.value->ulLen; ++ulPos )
{
PHB_ITEM pValue = &pHash->item.asHash.value->pPairs[ ulPos ].value;
if( HB_IS_BYREF( pValue ) )
hb_itemUnRef( pValue );
hb_itemCopy( &pDest->item.asHash.value->pPairs[ ulPos ].key,
&pHash->item.asHash.value->pPairs[ ulPos ].key );
pDest->item.asHash.value->ulLen++;
hb_cloneNested( &pDest->item.asHash.value->pPairs[ ulPos ].value, pValue, pClonedList );
}
}
| hashes.c | 601 |
HB_EXPORT PHB_ITEM | hb_hashClone( PHB_ITEM pHash )
HB_EXPORT PHB_ITEM hb_hashClone( PHB_ITEM pHash )
{
PHB_ITEM pDest;
HB_TRACE(HB_TR_DEBUG, ("hb_hashClone(%p)", pHash));
pDest = hb_itemNew( NULL );
if( HB_IS_HASH( pHash ) )
{
PHB_NESTED_CLONED pClonedList, pCloned;
pClonedList = ( PHB_NESTED_CLONED ) hb_xgrab( sizeof( HB_NESTED_CLONED ) );
pClonedList->value = ( void * ) pHash->item.asHash.value;
pClonedList->pDest = pDest;
pClonedList->pNext = NULL;
hb_hashCloneBody( pHash, pDest, pClonedList );
do
{
pCloned = pClonedList;
pClonedList = pClonedList->pNext;
hb_xfree( pCloned );
}
while( pClonedList );
}
return pDest;
}
| hashes.c | 625 |
HB_EXPORT VOID | hb_hashJoin( PHB_ITEM pDest, PHB_ITEM pSource, int iType )
HB_EXPORT void hb_hashJoin( PHB_ITEM pDest, PHB_ITEM pSource, int iType )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashJoin(%p,%p,%d)", pDest, pSource, iType));
if( HB_IS_HASH( pDest ) && HB_IS_HASH( pSource ) )
{
PHB_BASEHASH pBaseHash;
ULONG ulPos;
switch( iType )
{
case HB_HASH_UNION: /* OR */
pBaseHash = pSource->item.asHash.value;
for( ulPos = 0; ulPos < pBaseHash->ulLen; ++ulPos )
{
PHB_ITEM pVal = &pBaseHash->pPairs[ ulPos ].value;
if( HB_IS_BYREF( pVal ) )
pVal = hb_itemUnRef( pVal );
hb_hashAdd( pDest, &pBaseHash->pPairs[ ulPos ].key, pVal );
}
break;
case HB_HASH_INTERSECT: /* AND */
pBaseHash = pDest->item.asHash.value;
for( ulPos = 0; ulPos < pBaseHash->ulLen; ++ulPos )
{
if( !hb_hashFind( pSource->item.asHash.value,
&pBaseHash->pPairs[ ulPos ].key, NULL ) )
hb_hashDel( pDest, &pBaseHash->pPairs[ ulPos ].key );
}
break;
case HB_HASH_DIFFERENCE: /* XOR */
pBaseHash = pSource->item.asHash.value;
for( ulPos = 0; ulPos < pBaseHash->ulLen; ++ulPos )
{
if( !hb_hashDel( pDest, &pBaseHash->pPairs[ ulPos ].key ) )
{
PHB_ITEM pVal = &pBaseHash->pPairs[ ulPos ].value;
if( HB_IS_BYREF( pVal ) )
pVal = hb_itemUnRef( pVal );
hb_hashAdd( pDest, &pBaseHash->pPairs[ ulPos ].key, pVal );
}
}
break;
case HB_HASH_REMOVE: /* NOT -> h1 & ( h1 ^ h2 ) */
pBaseHash = pSource->item.asHash.value;
if( pDest->item.asHash.value == pBaseHash )
hb_hashClear( pDest );
else
{
for( ulPos = 0; ulPos < pBaseHash->ulLen; ++ulPos )
hb_hashDel( pDest, &pBaseHash->pPairs[ ulPos ].key );
}
break;
}
}
}
| hashes.c | 655 |
HB_EXPORT PHB_ITEM | hb_hashGetKeys( PHB_ITEM pHash )
HB_EXPORT PHB_ITEM hb_hashGetKeys( PHB_ITEM pHash )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetKeys(%p)", pHash));
if( HB_IS_HASH( pHash ) )
{
PHB_ITEM pKeys = hb_itemArrayNew( hb_hashLen( pHash ) ), pKey;
ULONG ulPos = 0;
while( ( pKey = hb_hashGetKeyAt( pHash, ++ulPos ) ) != NULL )
{
PHB_ITEM pDest = hb_arrayGetItemPtr( pKeys, ulPos );
if( !pDest )
break;
hb_itemCopy( pDest, pKey );
}
return pKeys;
}
return NULL;
}
| hashes.c | 715 |
HB_EXPORT PHB_ITEM | hb_hashGetValues( PHB_ITEM pHash )
HB_EXPORT PHB_ITEM hb_hashGetValues( PHB_ITEM pHash )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetValues(%p)", pHash));
if( HB_IS_HASH( pHash ) )
{
PHB_ITEM pValues = hb_itemArrayNew( hb_hashLen( pHash ) ), pVal;
ULONG ulPos = 0;
while( ( pVal = hb_hashGetValueAt( pHash, ++ulPos ) ) != NULL )
{
PHB_ITEM pDest = hb_arrayGetItemPtr( pValues, ulPos );
if( !pDest )
break;
hb_itemCopy( pDest, pVal );
}
return pValues;
}
return NULL;
}
| hashes.c | 737 |
HB_EXPORT VOID | hb_hashSetDefault( PHB_ITEM pHash, PHB_ITEM pValue )
HB_EXPORT void hb_hashSetDefault( PHB_ITEM pHash, PHB_ITEM pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashSetDefault(%p,%p)", pHash, pValue));
if( HB_IS_HASH( pHash ) )
{
if( pHash->item.asHash.value->pDefault )
{
hb_itemRelease( pHash->item.asHash.value->pDefault );
pHash->item.asHash.value->pDefault = NULL;
}
if( pValue && !HB_IS_NIL( pValue ) &&
( !HB_IS_HASH( pValue ) || pHash->item.asHash.value !=
pValue->item.asHash.value ) )
pHash->item.asHash.value->pDefault = hb_itemClone( pValue );
}
}
| hashes.c | 759 |
HB_EXPORT PHB_ITEM | hb_hashGetDefault( PHB_ITEM pHash )
HB_EXPORT PHB_ITEM hb_hashGetDefault( PHB_ITEM pHash )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetDefault(%p)", pHash));
if( HB_IS_HASH( pHash ) )
return pHash->item.asHash.value->pDefault;
else
return NULL;
}
| hashes.c | 777 |
HB_EXPORT VOID | hb_hashSetFlags( PHB_ITEM pHash, int iFlags )
HB_EXPORT void hb_hashSetFlags( PHB_ITEM pHash, int iFlags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashSetFlags(%p,%d)", pHash, iFlags));
if( HB_IS_HASH( pHash ) )
pHash->item.asHash.value->iFlags |= iFlags;
}
| hashes.c | 787 |
HB_EXPORT VOID | hb_hashClearFlags( PHB_ITEM pHash, int iFlags )
HB_EXPORT void hb_hashClearFlags( PHB_ITEM pHash, int iFlags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashClearFlags(%p,%d)", pHash, iFlags));
if( HB_IS_HASH( pHash ) )
pHash->item.asHash.value->iFlags &= ~iFlags;
}
| hashes.c | 795 |
HB_EXPORT INT | hb_hashGetFlags( PHB_ITEM pHash )
HB_EXPORT int hb_hashGetFlags( PHB_ITEM pHash )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetFlags(%p)", pHash));
if( HB_IS_HASH( pHash ) )
return pHash->item.asHash.value->iFlags;
else
return 0;
}
| hashes.c | 803 |
hashfunc.c |
Type | Function | Source | Line |
HB_FUNC | HB_HASH(void)
HB_FUNC( HB_HASH )
{
int iPCount = hb_pcount(), iParam;
if( iPCount & 1 )
hb_errRT_BASE( EG_BOUND, 1131, NULL, hb_langDGetErrorDesc( EG_ARRDIMENSION ), HB_ERR_ARGS_BASEPARAMS );
else
{
PHB_ITEM pHash = hb_hashNew( NULL );
for( iParam = 1; iParam <= iPCount; iParam += 2 )
{
PHB_ITEM pKey = hb_param( iParam, HB_IT_HASHKEY );
PHB_ITEM pValue = hb_param( iParam + 1, HB_IT_ANY );
if( pKey )
hb_hashAdd( pHash, pKey, pValue );
else
{
hb_errRT_BASE( EG_BOUND, 1133, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 3, pHash, hb_param( iParam, HB_IT_ANY ), pValue );
break;
}
}
hb_itemReturnRelease( pHash );
}
}
| hashfunc.c | 61 |
HB_FUNC | HB_HHASKEY(void)
HB_FUNC( HB_HHASKEY )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pKey = hb_param( 2, HB_IT_HASHKEY );
if( pHash && pKey )
hb_retl( hb_hashScan( pHash, pKey, NULL ) );
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 86 |
HB_FUNC | HB_HPOS(void)
HB_FUNC( HB_HPOS )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pKey = hb_param( 2, HB_IT_HASHKEY );
if( pHash && pKey )
{
ULONG ulPos;
hb_hashScan( pHash, pKey, &ulPos );
hb_retnint( ulPos );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 97 |
HB_FUNC | HB_HGET(void)
HB_FUNC( HB_HGET )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pKey = hb_param( 2, HB_IT_HASHKEY );
if( pHash && pKey )
{
PHB_ITEM pDest = hb_hashGetItemPtr( pHash, pKey, HB_HASH_AUTOADD_ACCESS );
if( pDest )
hb_itemReturn( HB_IS_BYREF( pDest ) ? hb_itemUnRef( pDest ) : pDest );
else
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 2, pHash, pKey );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 112 |
HB_FUNC | HB_HSET(void)
HB_FUNC( HB_HSET )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pKey = hb_param( 2, HB_IT_HASHKEY );
PHB_ITEM pValue = hb_param( 3, HB_IT_ANY );
if( pHash && pKey && pValue )
{
hb_hashAdd( pHash, pKey, pValue );
hb_itemReturn( pHash );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 129 |
HB_FUNC | HB_HDEL(void)
HB_FUNC( HB_HDEL )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pKey = hb_param( 2, HB_IT_HASHKEY );
if( pHash && pKey )
{
if( hb_hashDel( pHash, pKey ) )
hb_itemReturn( pHash );
else
hb_errRT_BASE( EG_BOUND, 1133, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 2, pHash, pKey );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 144 |
HB_FUNC | HB_HKEYAT(void)
HB_FUNC( HB_HKEYAT )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pPos = hb_param( 2, HB_IT_NUMERIC );
if( pHash && pPos )
{
PHB_ITEM pKey = hb_hashGetKeyAt( pHash, hb_itemGetNL( pPos ) );
if( pKey )
hb_itemReturn( pKey );
else
hb_errRT_BASE( EG_BOUND, 1187, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 160 |
HB_FUNC | HB_HVALUEAT(void)
HB_FUNC( HB_HVALUEAT )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pPos = hb_param( 2, HB_IT_NUMERIC );
PHB_ITEM pValue = hb_param( 3, HB_IT_ANY );
if( pHash && pPos )
{
PHB_ITEM pItem = hb_hashGetValueAt( pHash, hb_itemGetNL( pPos ) );
if( pItem )
{
if( pValue )
hb_itemCopy( pItem, pValue );
else
pValue = pItem;
hb_itemReturn( pValue );
}
else
hb_errRT_BASE( EG_BOUND, 1187, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 177 |
HB_FUNC | HB_HPAIRAT(void)
HB_FUNC( HB_HPAIRAT )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pPos = hb_param( 2, HB_IT_NUMERIC );
if( pHash && pPos )
{
PHB_ITEM pKey = hb_hashGetKeyAt( pHash, hb_itemGetNL( pPos ) );
PHB_ITEM pValue = hb_hashGetValueAt( pHash, hb_itemGetNL( pPos ) );
if( pKey && pValue )
{
PHB_ITEM pDstKey = hb_param( 3, HB_IT_BYREF );
PHB_ITEM pDstVal = hb_param( 4, HB_IT_BYREF );
if( pDstKey && pDstVal )
{
hb_itemCopy( pDstKey, pKey );
hb_itemCopy( pDstVal, pValue );
}
else
{
PHB_ITEM pResult = hb_itemArrayNew( 2 );
hb_arraySet( pResult, 1, pKey );
hb_arraySet( pResult, 2, pValue );
hb_itemReturnRelease( pResult );
}
}
else
hb_errRT_BASE( EG_BOUND, 1187, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 201 |
HB_FUNC | HB_HDELAT(void)
HB_FUNC( HB_HDELAT )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pPos = hb_param( 2, HB_IT_NUMERIC );
if( pHash && pPos )
{
if( hb_hashDelAt( pHash, hb_itemGetNL( pPos ) ) )
hb_itemReturn( pHash );
else
hb_errRT_BASE( EG_BOUND, 1133, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 2, pHash, pPos );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 234 |
HB_FUNC | HB_HKEYS(void)
HB_FUNC( HB_HKEYS )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
if( pHash )
hb_itemReturnRelease( hb_hashGetKeys( pHash ) );
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 251 |
HB_FUNC | HB_HVALUES(void)
HB_FUNC( HB_HVALUES )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
if( pHash )
hb_itemReturnRelease( hb_hashGetValues( pHash ) );
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 261 |
HB_FUNC | HB_HFILL(void)
HB_FUNC( HB_HFILL )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pValue = hb_param( 2, HB_IT_ANY );
if( pHash && pValue )
{
PHB_ITEM pDest;
ULONG ulPos = 0;
while( ( pDest = hb_hashGetValueAt( pHash, ++ulPos ) ) != NULL )
hb_itemCopy( pDest, pValue );
hb_itemReturn( pHash );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 271 |
HB_FUNC | HB_HCLONE(void)
HB_FUNC( HB_HCLONE )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
if( pHash )
hb_itemReturnRelease( hb_hashClone( pHash ) );
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 290 |
HB_FUNC | HB_HCOPY(void)
HB_FUNC( HB_HCOPY )
{
PHB_ITEM pSource = hb_param( 1, HB_IT_HASH );
PHB_ITEM pDest = hb_param( 2, HB_IT_HASH );
if( pSource && pDest )
{
ULONG ulLen = hb_hashLen( pSource ), ulStart, ulCount;
ulStart = hb_parnl( 3 );
if( !ulStart )
++ulStart;
ulCount = ISNUM( 4 ) ? ( ULONG ) hb_parnl( 4 ) : ulLen - ulStart + 1;
while( ulCount-- )
{
PHB_ITEM pKey = hb_hashGetKeyAt( pSource, ulStart );
PHB_ITEM pValue = hb_hashGetValueAt( pSource, ulStart );
if( pKey && pValue )
hb_hashAdd( pDest, pKey, pValue );
else
break;
++ulStart;
}
hb_itemReturn( pDest );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 300 |
HB_FUNC | HB_HMERGE(void)
HB_FUNC( HB_HMERGE )
{
PHB_ITEM pDest = hb_param( 1, HB_IT_HASH );
PHB_ITEM pSource = hb_param( 2, HB_IT_HASH );
PHB_ITEM pAction = hb_param( 3, HB_IT_BLOCK | HB_IT_NUMERIC );
if( pDest && pSource )
{
if( pAction && HB_IS_BLOCK( pAction ) )
{
ULONG ulLen = hb_hashLen( pSource ), ulPos = 0;
while( ++ulPos <= ulLen )
{
PHB_ITEM pKey = hb_hashGetKeyAt( pSource, ulPos );
PHB_ITEM pValue = hb_hashGetValueAt( pSource, ulPos );
if( pKey && pValue )
{
hb_vmPushEvalSym();
hb_vmPush( pAction );
hb_vmPush( pKey );
hb_vmPush( pValue );
hb_vmPushLong( ulPos );
hb_vmSend( 3 );
if( HB_IS_LOGICAL( hb_stackReturnItem() ) &&
hb_itemGetL( hb_stackReturnItem() ) )
hb_hashAdd( pDest, pKey, pValue );
}
else
break;
}
}
else
hb_hashJoin( pDest, pSource, pAction ? hb_itemGetNI( pAction ) : HB_HASH_UNION );
hb_itemReturn( pDest );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 331 |
HB_FUNC | HB_HEVAL(void)
HB_FUNC( HB_HEVAL )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pBlock = hb_param( 2, HB_IT_BLOCK );
if( pHash && pBlock )
{
ULONG ulLen = hb_hashLen( pHash ), ulStart, ulCount;
ulStart = hb_parnl( 3 );
if( !ulStart )
++ulStart;
ulCount = ISNUM( 4 ) ? ( ULONG ) hb_parnl( 4 ) : ulLen - ulStart + 1;
while( ulCount-- )
{
PHB_ITEM pKey = hb_hashGetKeyAt( pHash, ulStart );
PHB_ITEM pValue = hb_hashGetValueAt( pHash, ulStart );
if( pKey && pValue )
{
hb_vmPushEvalSym();
hb_vmPush( pBlock );
hb_vmPush( pKey );
hb_vmPush( pValue );
hb_vmPushLong( ulStart );
hb_vmSend( 3 );
}
else
break;
++ulStart;
}
hb_itemReturn( pHash );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 371 |
HB_FUNC | HB_HSCAN(void)
HB_FUNC( HB_HSCAN )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pValue = hb_param( 2, HB_IT_ANY );
if( pHash && pValue )
{
BOOL fExact = hb_parl( 5 ), fFound = FALSE;
ULONG ulLen = hb_hashLen( pHash ), ulStart, ulCount;
ulStart = hb_parnl( 3 );
if( !ulStart )
++ulStart;
ulCount = ISNUM( 4 ) ? ( ULONG ) hb_parnl( 4 ) : ulLen - ulStart + 1;
if( HB_IS_BLOCK( pValue ) )
{
while( ulCount-- )
{
PHB_ITEM pKey = hb_hashGetKeyAt( pHash, ulStart );
PHB_ITEM pVal = hb_hashGetValueAt( pHash, ulStart );
if( pKey && pValue )
{
hb_vmPushEvalSym();
hb_vmPush( pValue );
hb_vmPush( pKey );
hb_vmPush( pVal );
hb_vmPushLong( ulStart );
hb_vmSend( 3 );
if( HB_IS_LOGICAL( hb_stackReturnItem() ) &&
hb_itemGetL( hb_stackReturnItem() ) )
{
fFound = TRUE;
break;
}
}
else
break;
++ulStart;
}
}
else if( HB_IS_STRING( pValue ) )
{
while( ulCount-- )
{
PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart );
if( pItem )
{
if( HB_IS_STRING( pItem ) && hb_itemStrCmp( pItem, pValue, fExact ) == 0 )
{
fFound = TRUE;
break;
}
}
else
break;
++ulStart;
}
}
else if( HB_IS_NUMERIC( pValue ) )
{
double dValue = hb_itemGetND( pValue );
while( ulCount-- )
{
PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart );
if( pItem )
{
if( HB_IS_NUMERIC( pItem ) && hb_itemGetND( pItem ) == dValue )
{
fFound = TRUE;
break;
}
}
else
break;
++ulStart;
}
}
else if( HB_IS_DATE( pValue ) )
{
long lValue = hb_itemGetDL( pValue );
while( ulCount-- )
{
PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart );
if( pItem )
{
if( HB_IS_DATE( pItem ) && hb_itemGetDL( pItem ) == lValue )
{
fFound = TRUE;
break;
}
}
else
break;
++ulStart;
}
}
else if( HB_IS_LOGICAL( pValue ) )
{
BOOL fValue = hb_itemGetDL( pValue );
while( ulCount-- )
{
PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart );
if( pItem )
{
if( HB_IS_LOGICAL( pItem ) && hb_itemGetL( pItem ) == fValue )
{
fFound = TRUE;
break;
}
}
else
break;
++ulStart;
}
}
else if( HB_IS_NIL( pValue ) )
{
while( ulCount-- )
{
PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart );
if( pItem )
{
if( HB_IS_NIL( pItem ) )
{
fFound = TRUE;
break;
}
}
else
break;
++ulStart;
}
}
else if( HB_IS_POINTER( pValue ) )
{
while( ulCount-- )
{
PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart );
if( pItem )
{
if( HB_IS_POINTER( pItem ) &&
pItem->item.asPointer.value == pValue->item.asPointer.value )
{
fFound = TRUE;
break;
}
}
else
break;
++ulStart;
}
}
else if( fExact && HB_IS_ARRAY( pValue ) )
{
while( ulCount-- )
{
PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart );
if( pItem )
{
if( HB_IS_ARRAY( pItem ) &&
pItem->item.asArray.value == pValue->item.asArray.value )
{
fFound = TRUE;
break;
}
}
else
break;
++ulStart;
}
}
else if( fExact && HB_IS_HASH( pValue ) )
{
while( ulCount-- )
{
PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart );
if( pItem )
{
if( HB_IS_HASH( pItem ) &&
pItem->item.asHash.value == pValue->item.asHash.value )
{
fFound = TRUE;
break;
}
}
else
break;
++ulStart;
}
}
hb_retnint( fFound ? ulStart : 0 );
}
else
hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 409 |
HB_FUNC | HB_HCASEMATCH(void)
HB_FUNC( HB_HCASEMATCH )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pValue = hb_param( 2, HB_IT_LOGICAL );
if( pHash )
{
hb_retl( ( hb_hashGetFlags( pHash ) & HB_HASH_IGNORECASE ) == 0 );
if( pValue )
{
if( hb_itemGetL( pValue ) )
hb_hashClearFlags( pHash, HB_HASH_IGNORECASE );
else
hb_hashSetFlags( pHash, HB_HASH_IGNORECASE );
}
}
else
hb_errRT_BASE( EG_ARG, 2017, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 607 |
HB_FUNC | HB_HAUTOADD(void)
HB_FUNC( HB_HAUTOADD )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pValue = hb_param( 2, HB_IT_LOGICAL | HB_IT_NUMERIC );
if( pHash )
{
int iOldFlags = hb_hashGetFlags( pHash ) & HB_HASH_AUTOADD_MASK;
hb_retni( iOldFlags );
if( pValue )
{
if( HB_IS_LOGICAL( pValue ) )
{
if( hb_itemGetL( pValue ) )
hb_hashSetFlags( pHash, hb_hashGetDefault( pHash ) ?
HB_HASH_AUTOADD_ALWAYS : HB_HASH_AUTOADD_ASSIGN );
else if( iOldFlags )
hb_hashClearFlags( pHash, iOldFlags );
}
else
{
int iNewFlags = hb_itemGetNI( pValue );
if( ( iNewFlags | iOldFlags ) != iNewFlags )
hb_hashClearFlags( pHash, iOldFlags );
if( iNewFlags )
hb_hashSetFlags( pHash, iNewFlags );
}
}
}
else
hb_errRT_BASE( EG_ARG, 2017, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 627 |
HB_FUNC | HB_HALLOCATE(void)
HB_FUNC( HB_HALLOCATE )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
PHB_ITEM pValue = hb_param( 2, HB_IT_NUMERIC );
if( pHash && pValue )
{
LONG lMem = hb_itemGetNL( pValue );
if( lMem >= 0 )
hb_hashPreallocate( pHash, lMem );
}
else
hb_errRT_BASE( EG_ARG, 2017, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| hashfunc.c | 660 |
HB_FUNC | HB_HDEFAULT(void)
HB_FUNC( HB_HDEFAULT )
{
PHB_ITEM pHash = hb_param( 1, HB_IT_HASH );
if( pHash )
{
hb_itemReturn( hb_hashGetDefault( pHash ) );
if( hb_pcount() > 1 )
hb_hashSetDefault( pHash, hb_param( 2, HB_IT_ANY ) );
}
else
hb_errRT_BASE( EG_ARG, 2017, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
HB_FUNC( HB_HSETAUTOADD ) { HB_FUNC_EXEC( HB_HAUTOADD ); hb_itemReturn( hb_param( 1, HB_IT_HASH ) ); }
HB_FUNC( HB_HSETCASEMATCH ) { HB_FUNC_EXEC( HB_HCASEMATCH ); hb_itemReturn( hb_param( 1, HB_IT_HASH ) ); }
| hashfunc.c | 675 |
hvm.c |
Type | Function | Source | Line |
HB_EXPORT VOID | hb_vmAtInit( HB_INIT_FUNC pFunc, void * cargo )
HB_EXPORT void hb_vmAtInit( HB_INIT_FUNC pFunc, void * cargo )
{
PHB_FUNC_LIST pLst = ( PHB_FUNC_LIST ) hb_xgrab( sizeof( HB_FUNC_LIST ) );
pLst->pFunc = pFunc;
pLst->cargo = cargo;
pLst->pNext = s_InitFunctions;
s_InitFunctions = pLst;
}
| hvm.c | 278 |
HB_EXPORT VOID | hb_vmAtExit( HB_INIT_FUNC pFunc, void * cargo )
HB_EXPORT void hb_vmAtExit( HB_INIT_FUNC pFunc, void * cargo )
{
PHB_FUNC_LIST pLst = ( PHB_FUNC_LIST ) hb_xgrab( sizeof( HB_FUNC_LIST ) );
pLst->pFunc = pFunc;
pLst->cargo = cargo;
pLst->pNext = s_ExitFunctions;
s_ExitFunctions = pLst;
}
| hvm.c | 288 |
STATIC VOID | hb_vmCleanModuleFunctions( void )
static void hb_vmCleanModuleFunctions( void )
{
PHB_FUNC_LIST pLst;
while( s_InitFunctions )
{
pLst = s_InitFunctions;
s_InitFunctions = pLst->pNext;
hb_xfree( pLst );
}
while( s_ExitFunctions )
{
pLst = s_ExitFunctions;
s_ExitFunctions = pLst->pNext;
hb_xfree( pLst );
}
}
| hvm.c | 298 |
STATIC VOID | hb_vmDoModuleInitFunctions( void )
static void hb_vmDoModuleInitFunctions( void )
{
PHB_FUNC_LIST pLst = s_InitFunctions;
while( pLst )
{
pLst->pFunc( pLst->cargo );
pLst = pLst->pNext;
}
}
| hvm.c | 316 |
STATIC VOID | hb_vmDoModuleExitFunctions( void )
static void hb_vmDoModuleExitFunctions( void )
{
PHB_FUNC_LIST pLst = s_ExitFunctions;
while( pLst )
{
pLst->pFunc( pLst->cargo );
pLst = pLst->pNext;
}
}
| hvm.c | 327 |
STATIC VOID | hb_vmDoInitClip( void )
static void hb_vmDoInitClip( void )
{
PHB_DYNS pDynSym = hb_dynsymFind( "CLIPINIT" );
if( pDynSym && pDynSym->pSymbol->value.pFunPtr )
{
hb_vmPushSymbol( pDynSym->pSymbol );
hb_vmPushNil();
hb_vmDo( 0 );
}
}
| hvm.c | 339 |
HB_EXPORT VOID | hb_vmInit( BOOL bStartMainProc )
HB_EXPORT void hb_vmInit( BOOL bStartMainProc )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmInit()"));
/* initialize internal data structures */
s_aStatics.type = HB_IT_NIL;
s_bDebugging = FALSE;
hb_vmSymbolInit_RT(); /* initialize symbol table with runtime support functions */
s_pDynsDbgEntry = hb_dynsymFind( "__DBGENTRY" );
hb_xinit();
hb_stackInit();
hb_errInit();
/* initialize dynamic symbol for evaluating codeblocks */
hb_symEval.pDynSym = hb_dynsymGetCase( hb_symEval.szName );
hb_setInitialize(); /* initialize Sets */
hb_conInit(); /* initialize Console */
hb_memvarsInit();
hb_clsInit(); /* initialize Classy/OO system */
/* Set the language to the default */
/* This trick is needed to stringify the macro value */
hb_langSelectID( HB_MACRO2STRING( HB_LANG_DEFAULT ) );
/* Check for some internal switches */
s_VMFlags = hb_cmdargProcessVM( &s_VMCancelKey, &s_VMCancelKeyEx );
hb_inkeySetCancelKeys( s_VMCancelKey, s_VMCancelKeyEx );
#ifndef HB_NO_PROFILER
/* Initialize opcodes profiler support arrays */
{
ULONG ul;
for( ul = 0; ul < HB_P_LAST_PCODE; ul++ )
{
hb_ulOpcodesCalls[ ul ] = 0;
hb_ulOpcodesTime[ ul ] = 0;
}
}
#endif
if( s_pDynsDbgEntry )
{
/* Try to get C dbgEntry() function pointer */
if( !s_pFunDbgEntry )
hb_vmDebugEntry( HB_DBG_GETENTRY, 0, NULL, 0, 0 );
if( !s_pFunDbgEntry )
s_pFunDbgEntry = hb_vmDebugEntry;
}
/* emable executing PCODE (HVM reenter request) */
s_fHVMActive = TRUE;
/* Call functions that initializes static variables
* Static variables have to be initialized before any INIT functions
* because INIT function can use static variables
*/
hb_vmDoInitStatics();
/* call CLIPINIT function to initialize ErrorBlock() and __SetHelpK()
* Because on some platform the execution order of init functions
* is out of Harbour control then this function has to be called
* explicitly in VM initialization process before hb_vmDoInitFunctions()
* and not depends on INIT clause.
*/
hb_vmDoInitClip();
hb_clsDoInit(); /* initialize Classy .prg functions */
hb_vmDoModuleInitFunctions(); /* process AtInit registered functions */
hb_vmDoInitFunctions(); /* process defined INIT functions */
/* This is undocumented CA-Cl*pper, if there's a function called _APPMAIN
it will be executed first. [vszakats] */
{
PHB_DYNS pDynSym = hb_dynsymFind( "_APPMAIN" );
if( pDynSym && pDynSym->pSymbol->value.pFunPtr )
s_pSymStart = pDynSym->pSymbol;
#ifdef HARBOUR_START_PROCEDURE
else
{
/* if first char is '@' then start procedure were set by
programmer explicitly and should have the highest priority
in other case it's the name of first public function in
first linked moudule which is used if there is no
HARBOUR_START_PROCEDURE in code */
if( s_pszLinkedMain && *s_pszLinkedMain == '@' )
pDynSym = hb_dynsymFind( s_pszLinkedMain + 1 );
else
{
pDynSym = hb_dynsymFind( HARBOUR_START_PROCEDURE );
if( ! ( pDynSym && pDynSym->pSymbol->value.pFunPtr ) && s_pszLinkedMain )
pDynSym = hb_dynsymFind( s_pszLinkedMain );
}
if( pDynSym && pDynSym->pSymbol->value.pFunPtr )
s_pSymStart = pDynSym->pSymbol;
else
hb_errInternal( HB_EI_VMBADSTARTUP, NULL, HARBOUR_START_PROCEDURE, NULL );
}
#else
#ifndef HB_C52_STRICT
else if( bStartMainProc && ! s_pSymStart )
hb_errInternal( HB_EI_VMNOSTARTUP, NULL, NULL, NULL );
#endif
#endif
}
hb_vmSetExceptionHandler();
if( bStartMainProc && s_pSymStart )
{
int i;
int iArgCount;
hb_vmPushSymbol( s_pSymStart ); /* pushes first HB_FS_PUBLIC defined symbol to the stack */
hb_vmPushNil(); /* places NIL at self */
iArgCount = 0;
for( i = 1; i < hb_cmdargARGC(); i++ ) /* places application parameters on the stack */
{
char ** argv = hb_cmdargARGV();
/* Filter out any parameters beginning with //, like //INFO */
if( ! hb_cmdargIsInternal( argv[ i ], NULL ) )
{
hb_vmPushString( argv[ i ], strlen( argv[ i ] ) );
iArgCount++;
}
}
hb_vmDo( iArgCount ); /* invoke it with number of supplied parameters */
}
hb_vmUnsetExceptionHandler();
}
| hvm.c | 354 |
HB_EXPORT INT | hb_vmQuit( void )
HB_EXPORT int hb_vmQuit( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmQuit()"));
hb_vmDoExitFunctions(); /* process defined EXIT functions */
hb_idleShutDown();
/* process AtExit registered functions */
hb_vmDoModuleExitFunctions();
hb_vmCleanModuleFunctions();
/* deactivate debugger */
hb_vmDebuggerExit();
/* release all known items stored in subsystems */
hb_itemClear( hb_stackReturnItem() );
hb_stackRemove( 1 ); /* clear stack items, leave only initial symbol item */
hb_memvarsClear(); /* clear all PUBLIC (and PRIVATE if any) variables */
/* intentionally here to allow executing object destructors for all
* cross referenced items before we release classy subsystem
*/
hb_gcCollectAll();
/* Clear any pending actions so RDD shutdown process
* can be cleanly executed
*/
hb_stackSetActionRequest( 0 );
hb_rddShutDown();
/* stop executing PCODE (HVM reenter request) */
s_fHVMActive = FALSE;
hb_errExit();
hb_clsReleaseAll();
hb_itemClear( &s_aStatics );
/* release all remaining items */
hb_conRelease(); /* releases Console */
hb_setRelease(); /* releases Sets */
hb_vmReleaseLocalSymbols(); /* releases the local modules linked list */
hb_dynsymRelease(); /* releases the dynamic symbol table */
#ifndef HB_CDP_SUPPORT_OFF
hb_cdpReleaseAll(); /* releases codepages */
#endif
hb_itemClear( hb_stackReturnItem() );
/* release all known garbage */
if( hb_xquery( HB_MEM_USEDMAX ) ) /* check if fmstat is ON */
hb_gcCollectAll();
else
hb_gcReleaseAll();
hb_memvarsFree(); /* free memory allocated for memvars table */
hb_stackFree();
/* hb_dynsymLog(); */
hb_xexit();
return s_nErrorLevel;
}
| hvm.c | 496 |
HB_EXPORT VOID | hb_vmExecute( const BYTE * pCode, PHB_SYMB pSymbols )
HB_EXPORT void hb_vmExecute( const BYTE * pCode, PHB_SYMB pSymbols )
{
LONG w = 0;
BOOL bCanRecover = FALSE;
BOOL bDynCode = pSymbols == NULL || ( pSymbols->scope.value & HB_FS_DYNCODE ) != 0;
#ifndef HB_NO_PROFILER
ULONG ulLastOpcode = 0; /* opcodes profiler support */
ULONG ulPastClock = 0; /* opcodes profiler support */
#endif
#ifndef HB_GUI
static unsigned short uiPolls = 1;
#endif
HB_TRACE(HB_TR_DEBUG, ("hb_vmExecute(%p, %p)", pCode, pSymbols));
#ifndef HB_NO_PROFILER
if( hb_bProfiler )
ulPastClock = ( ULONG ) clock();
#endif
while( TRUE )
{
#ifndef HB_NO_PROFILER
if( hb_bProfiler )
{
ULONG ulActualClock = ( ULONG ) clock();
hb_ulOpcodesTime[ ulLastOpcode ] += ( ulActualClock - ulPastClock );
ulPastClock = ulActualClock;
ulLastOpcode = pCode[ w ];
hb_ulOpcodesCalls[ ulLastOpcode ]++;
}
#endif
#ifndef HB_GUI
if( ! --uiPolls )
{
hb_inkeyPoll();
/* uiPolls = 255; */
/* IMHO we should have a _SET_ controlled by user
* sth like:
if( hb_set.HB_SET_KEYPOLL )
{
hb_inkeyPoll();
uiPolls = hb_set.HB_SET_KEYPOLL;
}
for some GTs which can work in assynchrous mode user may
set it to 0 (or if he doesn't need any inkey poll) and
when ALT+C/ALT+D is pressed (or any other platform dependent
key combination) they should set proper flags in
ActionRequest so we can serve it in main VM loop without
performance decrease or ignore depending on
hb_set.HB_SET_CANCEL, hb_set.HB_SET_DEBUG flags
*/
}
#endif
switch( pCode[ w ] )
{
/* Operators ( mathematical / character / misc ) */
case HB_P_NEGATE:
hb_vmNegate();
w++;
break;
case HB_P_PLUS:
hb_vmPlus( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
w++;
break;
case HB_P_PLUSEQ:
{
HB_ITEM_PTR pResult, pValue;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmPlus( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackDec();
}
w++;
break;
case HB_P_PLUSEQPOP:
{
HB_ITEM_PTR pResult;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmPlus( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
}
w++;
break;
case HB_P_MINUS:
hb_vmMinus( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
w++;
break;
case HB_P_MINUSEQ:
{
HB_ITEM_PTR pResult, pValue;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmMinus( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackDec();
}
w++;
break;
case HB_P_MINUSEQPOP:
{
HB_ITEM_PTR pResult;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmMinus( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
}
w++;
break;
case HB_P_MULT:
hb_vmMult( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
w++;
break;
case HB_P_MULTEQ:
{
HB_ITEM_PTR pResult, pValue;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmMult( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackDec();
}
w++;
break;
case HB_P_MULTEQPOP:
{
HB_ITEM_PTR pResult;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmMult( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
}
w++;
break;
case HB_P_DIVIDE:
hb_vmDivide( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
w++;
break;
case HB_P_DIVEQ:
{
HB_ITEM_PTR pResult, pValue;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmDivide( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackDec();
}
w++;
break;
case HB_P_DIVEQPOP:
{
HB_ITEM_PTR pResult;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmDivide( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
}
w++;
break;
case HB_P_MODULUS:
hb_vmModulus( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
w++;
break;
case HB_P_MODEQ:
{
HB_ITEM_PTR pResult, pValue;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmModulus( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackDec();
}
w++;
break;
case HB_P_MODEQPOP:
{
HB_ITEM_PTR pResult;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmModulus( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
}
w++;
break;
case HB_P_POWER:
hb_vmPower( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
w++;
break;
case HB_P_EXPEQ:
{
HB_ITEM_PTR pResult, pValue;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmPower( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackDec();
}
w++;
break;
case HB_P_EXPEQPOP:
{
HB_ITEM_PTR pResult;
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmPower( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
}
w++;
break;
case HB_P_INC:
hb_vmInc( hb_stackItemFromTop( -1 ) );
w++;
break;
case HB_P_INCEQ:
{
HB_ITEM_PTR pResult, pValue, pTemp;
pResult = hb_stackItemFromTop( -1 );
pValue = hb_itemUnRef( pResult );
hb_vmInc( pValue );
pTemp = hb_stackAllocItem();
hb_itemCopy( pTemp, pValue );
hb_itemMove( pResult, pTemp );
hb_stackDec();
w++;
}
break;
case HB_P_INCEQPOP:
hb_vmInc( hb_itemUnRef( hb_stackItemFromTop( -1 ) ) );
hb_stackPop();
w++;
break;
case HB_P_DEC:
hb_vmDec( hb_stackItemFromTop( -1 ) );
w++;
break;
case HB_P_DECEQ:
{
HB_ITEM_PTR pResult, pValue, pTemp;
pResult = hb_stackItemFromTop( -1 );
pValue = hb_itemUnRef( pResult );
hb_vmDec( pValue );
pTemp = hb_stackAllocItem();
hb_itemCopy( pTemp, pValue );
hb_itemMove( pResult, pTemp );
hb_stackDec();
w++;
}
break;
case HB_P_DECEQPOP:
hb_vmDec( hb_itemUnRef( hb_stackItemFromTop( -1 ) ) );
hb_stackPop();
w++;
break;
case HB_P_FUNCPTR:
hb_vmFuncPtr();
w++;
break;
/* Operators (relational) */
case HB_P_EQUAL:
hb_vmEqual();
w++;
break;
case HB_P_EXACTLYEQUAL:
hb_vmExactlyEqual();
w++;
break;
case HB_P_NOTEQUAL:
hb_vmNotEqual();
w++;
break;
case HB_P_LESS:
hb_vmLess();
w++;
break;
case HB_P_LESSEQUAL:
hb_vmLessEqual();
w++;
break;
case HB_P_GREATER:
hb_vmGreater();
w++;
break;
case HB_P_GREATEREQUAL:
hb_vmGreaterEqual();
w++;
break;
case HB_P_INSTRING:
hb_vmInstring();
w++;
break;
case HB_P_FORTEST:
hb_vmForTest();
w++;
break;
case HB_P_ENUMSTART:
hb_vmEnumStart( pCode[ w + 1 ], pCode[ w + 2 ] );
w += 3;
break;
case HB_P_ENUMNEXT:
hb_vmEnumNext();
w++;
break;
case HB_P_ENUMPREV:
hb_vmEnumPrev();
w++;
break;
case HB_P_ENUMEND:
hb_vmEnumEnd();
w++;
break;
case HB_P_SWITCH:
w = hb_vmSwitch( pCode, w+3, HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
break;
/* Operators (logical) */
case HB_P_NOT:
hb_vmNot();
w++;
break;
case HB_P_AND:
hb_vmAnd();
w++;
break;
case HB_P_OR:
hb_vmOr();
w++;
break;
/* Array */
case HB_P_ARRAYPUSH:
hb_vmArrayPush();
w++;
break;
case HB_P_ARRAYPUSHREF:
hb_vmArrayPushRef();
w++;
break;
case HB_P_ARRAYPOP:
hb_vmArrayPop();
w++;
break;
case HB_P_ARRAYDIM:
hb_vmArrayDim( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_ARRAYGEN:
hb_vmArrayGen( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_HASHGEN:
hb_vmHashGen( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
/* Object */
case HB_P_MESSAGE:
hb_vmPushSymbol( pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
/* Database */
case HB_P_SWAPALIAS:
hb_vmSwapAlias();
w++;
break;
/* Execution */
case HB_P_DO:
hb_vmDo( HB_PCODE_MKUSHORT( &( pCode[ w + 1 ] ) ) );
w += 3;
break;
case HB_P_DOSHORT:
hb_vmDo( pCode[ w + 1 ] );
w += 2;
break;
case HB_P_FUNCTION:
hb_itemSetNil( hb_stackReturnItem() );
hb_vmDo( HB_PCODE_MKUSHORT( &( pCode[ w + 1 ] ) ) );
hb_stackPushReturn();
w += 3;
break;
case HB_P_FUNCTIONSHORT:
hb_itemSetNil( hb_stackReturnItem() );
hb_vmDo( pCode[ w + 1 ] );
hb_stackPushReturn();
w += 2;
break;
case HB_P_SEND:
hb_itemSetNil( hb_stackReturnItem() );
hb_vmSend( HB_PCODE_MKUSHORT( &( pCode[ w + 1 ] ) ) );
w += 3;
/* Is This OK??? */
if( pCode[ w ] == HB_P_POP )
w++;
else
hb_stackPushReturn();
break;
case HB_P_SENDSHORT:
hb_itemSetNil( hb_stackReturnItem() );
hb_vmSend( pCode[ w + 1 ] );
w += 2;
if( pCode[ w ] == HB_P_POP )
w++;
else
hb_stackPushReturn();
break;
case HB_P_PUSHOVARREF:
hb_vmPushObjectVarRef();
w++;
break;
case HB_P_LINE:
HB_TRACE(HB_TR_INFO, ("Opcode: HB_P_LINE: %s (%i)",
hb_stackBaseItem()->item.asSymbol.value->szName,
hb_stackBaseItem()->item.asSymbol.stackstate->uiLineNo));
hb_stackBaseItem()->item.asSymbol.stackstate->uiLineNo = HB_PCODE_MKUSHORT( &pCode[ w + 1 ] );
#ifndef HB_NO_DEBUG
if( s_bDebugging )
hb_vmDebuggerShowLine( hb_stackBaseItem()->item.asSymbol.stackstate->uiLineNo );
#endif
w += 3;
break;
case HB_P_PARAMETER:
hb_memvarNewParameter( pSymbols + HB_PCODE_MKUSHORT( &( pCode[ w + 1 ] ) ), hb_stackItemFromBase( pCode[ w + 3 ] ) );
HB_TRACE(HB_TR_INFO, ("(hb_vmPopParameter)"));
w += 4;
break;
case HB_P_FRAME:
hb_vmFrame( pCode[ w + 1 ], pCode[ w + 2 ] );
w += 3;
break;
case HB_P_VFRAME:
hb_vmVFrame( pCode[ w + 1 ], pCode[ w + 2 ] );
w += 3;
break;
case HB_P_LARGEFRAME:
hb_vmFrame( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ), pCode[ w + 3 ] );
w += 4;
break;
case HB_P_LARGEVFRAME:
hb_vmVFrame( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ), pCode[ w + 3 ] );
w += 4;
break;
case HB_P_SFRAME:
hb_vmSFrame( pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_STATICS:
hb_vmStatics( pSymbols + HB_PCODE_MKUSHORT( &( pCode[ w + 1 ] ) ), HB_PCODE_MKUSHORT( &( pCode[ w + 3 ] ) ) );
w += 5;
break;
case HB_P_RETVALUE:
hb_vmRetValue();
w++;
break;
case HB_P_LOCALNAME:
hb_vmLocalName( HB_PCODE_MKUSHORT( &( pCode[ w + 1 ] ) ),
( char * ) pCode + w + 3 );
w += 3;
while( pCode[ w++ ] );
break;
case HB_P_STATICNAME:
hb_vmStaticName( pCode[ w + 1 ], HB_PCODE_MKUSHORT( &( pCode[ w + 2 ] ) ),
( char * ) pCode + w + 4 );
w += 4;
while( pCode[ w++ ] );
break;
case HB_P_MODULENAME:
hb_vmModuleName( ( char * ) pCode + w + 1 );
while( pCode[ w++ ] );
break;
case HB_P_ENDBLOCK:
HB_TRACE(HB_TR_INFO, ("HB_P_ENDBLOCK"));
hb_vmEndBlock();
/* manually inlined hb_vmRequestEndProc() for some C compilers
* which does not make such optimisation
*/
hb_stackSetActionRequest( HB_ENDPROC_REQUESTED );
break;
case HB_P_ENDPROC:
HB_TRACE(HB_TR_INFO, ("HB_P_ENDPROC"));
/* manually inlined hb_vmRequestEndProc() for some C compilers
* which does not make such optimisation
*/
hb_stackSetActionRequest( HB_ENDPROC_REQUESTED );
break;
/* BEGIN SEQUENCE/RECOVER/ALWAYS/END SEQUENCE */
case HB_P_SEQBLOCK:
hb_vmSeqBlock();
w++;
break;
case HB_P_SEQALWAYS:
{
/*
* Create the SEQUENCE envelope
* [ break return value ] -2
* [ recover envelope ] -1
* [ ] <- new recover base
*/
PHB_ITEM pItem;
/*
* 1) clear the storage for value returned by BREAK statement
*/
hb_stackAllocItem()->type = HB_IT_NIL;
/*
* 2) recover data
*/
pItem = hb_stackAllocItem();
/* mark type as NIL - it's not real item */
pItem->type = HB_IT_NIL;
/* store the address of RECOVER or END opcode */
pItem->item.asRecover.recover = w + HB_PCODE_MKINT24( &pCode[ w + 1 ] );
/* store current RECOVER base */
pItem->item.asRecover.base = hb_stackGetRecoverBase();
/* store current bCanRecover flag - in a case of nested sequences */
pItem->item.asRecover.flags = HB_SEQ_DOALWAYS | ( bCanRecover ? HB_SEQ_CANRECOVER : 0 );
/* clear new recovery state */
pItem->item.asRecover.request = 0;
/*
* set new recover base
*/
hb_stackSetRecoverBase( hb_stackTopOffset() );
/*
* we are now inside a valid SEQUENCE envelope
*/
bCanRecover = TRUE;
w += 4;
break;
}
case HB_P_ALWAYSBEGIN:
/* change the recover address to ALWAYSEND opcode */
hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.recover =
w + HB_PCODE_MKINT24( &pCode[ w + 1 ] );
/* store and reset action */
hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.flags |=
hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.request;
hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.request = 0;
/* store RETURN value */
if( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.flags & HB_ENDPROC_REQUESTED )
hb_itemMove( hb_stackItemFromTop( HB_RECOVER_VALUE ), hb_stackReturnItem() );
w += 4;
break;
case HB_P_ALWAYSEND:
{
USHORT uiPrevAction, uiCurrAction;
uiPrevAction = hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.flags;
uiCurrAction = hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.request;
/* restore previous recovery base */
bCanRecover = ( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.flags & HB_SEQ_CANRECOVER ) != 0;
hb_stackSetRecoverBase( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.base );
/* restore requested action */
if( ( uiCurrAction | uiPrevAction ) & HB_QUIT_REQUESTED )
hb_stackSetActionRequest( HB_QUIT_REQUESTED );
else if( ( uiCurrAction | uiPrevAction ) & HB_BREAK_REQUESTED )
hb_stackSetActionRequest( HB_BREAK_REQUESTED );
else if( ( uiCurrAction | uiPrevAction ) & HB_ENDPROC_REQUESTED )
hb_stackSetActionRequest( HB_ENDPROC_REQUESTED );
else
hb_stackSetActionRequest( 0 );
/* Remove the ALWAYS envelope */
hb_stackDec();
/* restore RETURN value if not overloaded inside ALWAYS code */
if( !( uiCurrAction & HB_ENDPROC_REQUESTED ) &&
( uiPrevAction & HB_ENDPROC_REQUESTED ) )
hb_stackPopReturn();
else
hb_stackPop();
w++;
break;
}
case HB_P_SEQBEGIN:
{
/*
* Create the SEQUENCE envelope
* [ break return value ] -2
* [ recover envelope ] -1
* [ ] <- new recover base
*/
PHB_ITEM pItem;
/*
* 1) clear the storage for value returned by BREAK statement
*/
hb_stackAllocItem()->type = HB_IT_NIL;
/*
* 2) recover data
*/
pItem = hb_stackAllocItem();
/* mark type as NIL - it's not real item */
pItem->type = HB_IT_NIL;
/* store the address of RECOVER or END opcode */
pItem->item.asRecover.recover = w + HB_PCODE_MKINT24( &pCode[ w + 1 ] );
/* store current RECOVER base */
pItem->item.asRecover.base = hb_stackGetRecoverBase();
/* store current bCanRecover flag - in a case of nested sequences */
pItem->item.asRecover.flags = bCanRecover ? HB_SEQ_CANRECOVER : 0;
/* clear new recovery state */
pItem->item.asRecover.request = 0;
/*
* set new recover base
*/
hb_stackSetRecoverBase( hb_stackTopOffset() );
/*
* we are now inside a valid SEQUENCE envelope
*/
bCanRecover = TRUE;
w += 4;
break;
}
case HB_P_SEQEND:
/*
* Remove the SEQUENCE envelope
* This is executed either at the end of sequence or as the
* response to the break statement if there is no RECOVER clause
*/
/*
* 2) Restore previous recovery state
*/
bCanRecover = ( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.flags & HB_SEQ_CANRECOVER ) != 0;
hb_stackSetRecoverBase( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.base );
hb_stackDec();
/*
* 1) Discard the value returned by BREAK statement - there
* was no RECOVER clause or there was no BREAK statement
*/
hb_stackPop();
/*
* skip outside of SEQUENCE structure
*/
w += HB_PCODE_MKINT24( &pCode[ w + 1 ] );
break;
case HB_P_SEQRECOVER:
/*
* Execute the RECOVER code
*/
/*
* 2) Restore previous recovery state
*/
bCanRecover = ( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.flags & HB_SEQ_CANRECOVER ) != 0;
hb_stackSetRecoverBase( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.base );
hb_stackDec();
/*
* 1) Leave the value returned from BREAK - it will be popped
* in next executed opcode
*/
w++;
break;
/* Jumps */
case HB_P_JUMPNEAR:
w += (signed char) pCode[ w + 1 ];
break;
case HB_P_JUMP:
w += HB_PCODE_MKSHORT( &( pCode[ w + 1 ] ) );
break;
case HB_P_JUMPFAR:
w += HB_PCODE_MKINT24( &pCode[ w + 1 ] );
break;
case HB_P_JUMPFALSENEAR:
if( ! hb_vmPopLogical() )
w += (signed char) pCode[ w + 1 ];
else
w += 2;
break;
case HB_P_JUMPFALSE:
if( ! hb_vmPopLogical() )
w += HB_PCODE_MKSHORT( &pCode[ w + 1 ] );
else
w += 3;
break;
case HB_P_JUMPFALSEFAR:
if( ! hb_vmPopLogical() )
w += HB_PCODE_MKINT24( &pCode[ w + 1 ] );
else
w += 4;
break;
case HB_P_JUMPTRUENEAR:
if( hb_vmPopLogical() )
w += (signed char) pCode[ w + 1 ];
else
w += 2;
break;
case HB_P_JUMPTRUE:
if( hb_vmPopLogical() )
w += HB_PCODE_MKSHORT( &pCode[ w + 1 ] );
else
w += 3;
break;
case HB_P_JUMPTRUEFAR:
if( hb_vmPopLogical() )
w += HB_PCODE_MKINT24( &pCode[ w + 1 ] );
else
w += 4;
break;
/* Push */
case HB_P_TRUE:
{
PHB_ITEM pItem = hb_stackAllocItem();
pItem->type = HB_IT_LOGICAL;
pItem->item.asLogical.value = TRUE;
w++;
}
break;
case HB_P_FALSE:
{
PHB_ITEM pItem = hb_stackAllocItem();
pItem->type = HB_IT_LOGICAL;
pItem->item.asLogical.value = FALSE;
w++;
}
break;
case HB_P_ONE:
{
PHB_ITEM pItem = hb_stackAllocItem();
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = 1;
pItem->item.asInteger.length = 10;
HB_TRACE(HB_TR_INFO, ("(HB_P_ONE)"));
w++;
}
break;
case HB_P_ZERO:
{
PHB_ITEM pItem = hb_stackAllocItem();
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = 0;
pItem->item.asInteger.length = 10;
HB_TRACE(HB_TR_INFO, ("(HB_P_ZERO)"));
w++;
}
break;
case HB_P_PUSHNIL:
hb_stackAllocItem()->type = HB_IT_NIL;
HB_TRACE(HB_TR_INFO, ("(HB_P_PUSHNIL)"));
w++;
break;
case HB_P_PUSHBYTE:
{
PHB_ITEM pItem = hb_stackAllocItem();
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = ( signed char ) pCode[ w + 1 ];
pItem->item.asInteger.length = 10;
HB_TRACE(HB_TR_INFO, ("(HB_P_PUSHBYTE)"));
w += 2;
}
break;
case HB_P_PUSHINT:
HB_TRACE(HB_TR_INFO, ("(HB_P_PUSHINT)"));
hb_vmPushInteger( HB_PCODE_MKSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_PUSHLONG:
HB_TRACE( HB_TR_DEBUG, ("(HB_P_PUSHLONG)") );
#if HB_INT_MAX >= INT32_MAX
hb_vmPushIntegerConst( ( int ) HB_PCODE_MKLONG( &pCode[ w + 1 ] ) );
#else
hb_vmPushLongConst( ( long ) HB_PCODE_MKLONG( &pCode[ w + 1 ] ) );
#endif
w += 5;
break;
case HB_P_PUSHLONGLONG:
HB_TRACE( HB_TR_DEBUG, ("(HB_P_PUSHLONGLONG)") );
#if !defined( HB_LONG_LONG_OFF )
hb_vmPushLongLongConst( HB_PCODE_MKLONGLONG( &pCode[ w + 1 ] ) );
#else
hb_vmPushDoubleConst( HB_PCODE_MKLONGLONG( &pCode[ w + 1 ] ),
HB_DEFAULT_WIDTH, HB_DEFAULT_DECIMALS );
#endif
w += 9;
break;
case HB_P_PUSHDOUBLE:
hb_vmPushDoubleConst( HB_PCODE_MKDOUBLE( &pCode[ w + 1 ] ),
( int ) * ( BYTE * ) &pCode[ w + 1 + sizeof( double ) ],
( int ) * ( BYTE * ) &pCode[ w + 1 + sizeof( double ) + sizeof( BYTE ) ] );
w += 1 + sizeof( double ) + sizeof( BYTE ) + sizeof( BYTE );
break;
case HB_P_PUSHSTRSHORT:
if( bDynCode )
hb_vmPushString( ( char * ) pCode + w + 2, ( ULONG ) pCode[ w + 1 ] - 1 );
else
hb_vmPushStringPcode( ( char * ) pCode + w + 2, ( ULONG ) pCode[ w + 1 ] - 1 );
w += 2 + pCode[ w + 1 ];
break;
case HB_P_PUSHSTR:
{
USHORT uiSize = HB_PCODE_MKUSHORT( &pCode[ w + 1 ] );
if( bDynCode )
hb_vmPushString( ( char * ) pCode + w + 3, uiSize - 1 );
else
hb_vmPushStringPcode( ( char * ) pCode + w + 3, uiSize - 1 );
w += 3 + uiSize;
break;
}
case HB_P_PUSHSTRLARGE:
{
ULONG ulSize = HB_PCODE_MKUINT24( &pCode[ w + 1 ] );
if( bDynCode )
hb_vmPushString( ( char * ) pCode + w + 4, ulSize - 1 );
else
hb_vmPushStringPcode( ( char * ) pCode + w + 4, ulSize - 1 );
w += 4 + ulSize;
break;
}
case HB_P_PUSHSTRHIDDEN:
{
ULONG ulSize = ( ULONG ) HB_PCODE_MKUSHORT( &pCode[ w + 2 ] );
char * szText = hb_compDecodeString( pCode[ w + 1 ], ( char * ) pCode + w + 4, &ulSize );
hb_itemPutCLPtr( hb_stackAllocItem(), szText, ulSize );
w += ( 4 + ulSize );
break;
}
case HB_P_PUSHDATE:
HB_TRACE( HB_TR_DEBUG, ("(HB_P_PUSHDATE)") );
hb_vmPushDate( ( long ) HB_PCODE_MKLONG( &pCode[ w + 1 ] ) );
w += 5;
break;
case HB_P_PUSHBLOCK:
{
/* +0 -> _pushblock
* +1 +2 -> size of codeblock
* +3 +4 -> number of expected parameters
* +5 +6 -> number of referenced local variables
* +7 -> start of table with referenced local variables
*/
ULONG ulSize = HB_PCODE_MKUSHORT( &pCode[ w + 1 ] );
hb_vmPushBlock( ( const BYTE * ) ( pCode + w + 3 ), pSymbols, bDynCode ? ulSize - 7 : 0 );
w += ulSize;
break;
}
case HB_P_PUSHBLOCKLARGE:
{
/* +0 -> _pushblock
* +1 +2 +3 -> size of codeblock
* +4 +5 -> number of expected parameters
* +6 +7 -> number of referenced local variables
* +8 -> start of table with referenced local variables
*/
ULONG ulSize = HB_PCODE_MKUINT24( &pCode[ w + 1 ] );
hb_vmPushBlock( ( const BYTE * ) ( pCode + w + 4 ), pSymbols, bDynCode ? ulSize - 8 : 0 );
w += ulSize;
break;
}
case HB_P_PUSHBLOCKSHORT:
{
/* +0 -> _pushblock
* +1 -> size of codeblock
*/
ULONG ulSize = pCode[ w + 1 ];
hb_vmPushBlockShort( ( const BYTE * ) ( pCode + w + 2 ), pSymbols, bDynCode ? ulSize - 2 : 0 );
w += ulSize;
break;
}
case HB_P_PUSHSELF:
hb_vmPush( hb_stackSelfItem() );
w++;
break;
case HB_P_PUSHSYM:
hb_vmPushSymbol( pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_PUSHSYMNEAR:
hb_vmPushSymbol( pSymbols + pCode[ w + 1 ] );
w += 2;
break;
case HB_P_PUSHFUNCSYM:
hb_vmPushSymbol( pSymbols + HB_PCODE_MKUSHORT( &( pCode[ w + 1 ] ) ) );
hb_stackAllocItem()->type = HB_IT_NIL;
w += 3;
break;
case HB_P_PUSHALIAS:
hb_vmPushAlias();
w++;
break;
case HB_P_PUSHALIASEDFIELD:
hb_vmPushAliasedField( pSymbols + HB_PCODE_MKUSHORT( &( pCode[ w + 1 ] ) ) );
w += 3;
break;
case HB_P_PUSHALIASEDFIELDNEAR:
hb_vmPushAliasedField( pSymbols + pCode[ w + 1 ] );
w += 2;
break;
case HB_P_PUSHALIASEDVAR:
hb_vmPushAliasedVar( pSymbols + HB_PCODE_MKUSHORT( &( pCode[ w + 1 ] ) ) );
w += 3;
break;
case HB_P_PUSHFIELD:
/* It pushes the current value of the given field onto the eval stack
*/
hb_rddGetFieldValue( hb_stackAllocItem(), pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
HB_TRACE(HB_TR_INFO, ("(hb_vmPushField)"));
w += 3;
break;
case HB_P_PUSHLOCAL:
hb_vmPushLocal( HB_PCODE_MKSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_PUSHLOCALNEAR:
hb_vmPushLocal( ( signed char ) pCode[ w + 1 ] );
w += 2; /* only first two bytes are used */
break;
case HB_P_PUSHLOCALREF:
hb_vmPushLocalByRef( HB_PCODE_MKSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_PUSHSTATIC:
hb_vmPushStatic( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_PUSHSTATICREF:
hb_vmPushStaticByRef( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_PUSHMEMVAR:
hb_memvarGetValue( hb_stackAllocItem(), pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
HB_TRACE(HB_TR_INFO, ("(hb_vmPushMemvar)"));
w += 3;
break;
case HB_P_PUSHMEMVARREF:
hb_memvarGetRefer( hb_stackAllocItem(), pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
HB_TRACE(HB_TR_INFO, ("(hb_vmPushMemvarRef)"));
w += 3;
break;
case HB_P_PUSHVARIABLE:
/* Push a value of variable of unknown type onto the eval stack
*/
hb_vmPushVariable( pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_DUPLICATE:
hb_vmDuplicate();
w++;
break;
case HB_P_DUPLTWO:
hb_vmDuplTwo();
w++;
break;
case HB_P_DUPLUNREF:
hb_vmDuplUnRef();
w++;
break;
case HB_P_PUSHUNREF:
hb_vmPushUnRef();
w++;
break;
case HB_P_PUSHVPARAMS:
hb_vmPushVParams();
w++;
break;
case HB_P_SWAP:
hb_vmSwap( pCode[ w + 1 ] );
w+=2;
break;
/* Pop */
case HB_P_POP:
hb_stackPop();
w++;
break;
case HB_P_POPALIAS:
hb_vmPopAlias();
w++;
break;
case HB_P_POPALIASEDFIELD:
hb_vmPopAliasedField( pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_POPALIASEDFIELDNEAR:
hb_vmPopAliasedField( pSymbols + pCode[ w + 1 ] );
w += 2;
break;
case HB_P_POPALIASEDVAR:
hb_vmPopAliasedVar( pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_POPFIELD:
/* Pops a value from the eval stack and uses it to set
* a new value of the given field
*/
hb_rddPutFieldValue( hb_stackItemFromTop(-1), pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
hb_stackPop();
HB_TRACE(HB_TR_INFO, ("(hb_vmPopField)"));
w += 3;
break;
case HB_P_POPLOCAL:
hb_vmPopLocal( HB_PCODE_MKSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_POPLOCALNEAR:
hb_vmPopLocal( ( signed char ) pCode[ w + 1 ] );
w += 2; /* only first two bytes are used */
break;
case HB_P_POPSTATIC:
hb_vmPopStatic( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_POPMEMVAR:
hb_memvarSetValue( pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ),
hb_stackItemFromTop( -1 ) );
hb_stackPop();
HB_TRACE(HB_TR_INFO, ("(hb_vmPopMemvar)"));
w += 3;
break;
case HB_P_POPVARIABLE:
{
/*
2004-03-19 Ron Pinkas
Test with Clipper shows that for assignment, MEMVAR context
is always used even if MEMVAR does NOT exists, and a FIELD
with this name exists!!!
Here is the Test Ueed - Clipper produced NO R/T Error -
indicating MEMVAR was created.
PROCEDURE Main()
USE Test
First := First
CLOSE
? First
RETURN
*/
#if 0
/* Pops a value from the eval stack and uses it to set
* a new value of a variable of unknown type.
*/
PHB_SYMB pSymbol = pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] );
if( pSymbol->pDynSym && pSymbol->pDynSym->hMemvar )
/* If exist a memory symbol with this name use it */
hb_memvarSetValue( pSymbol, hb_stackItemFromTop(-1) );
else if( hb_rddFieldPut( hb_stackItemFromTop(-1), pSymbol ) == FAILURE )
/* Try with a field and after create a memvar */
hb_memvarSetValue( pSymbol, hb_stackItemFromTop(-1) );
#else
hb_memvarSetValue( pSymbols + HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ),
hb_stackItemFromTop( -1 ) );
#endif
hb_stackPop();
HB_TRACE(HB_TR_INFO, ("(hb_vmPopVariable)"));
w += 3;
break;
}
/* macro creation */
case HB_P_MACROPOP:
/* compile and run - pop a value from the stack */
hb_macroSetValue( hb_stackItemFromTop( -1 ), pCode[ ++w ] );
w++;
break;
case HB_P_MACROPOPALIASED:
/* compile and run - pop an aliased variable from the stack */
hb_macroPopAliasedValue( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ), pCode[ ++w ] );
w++;
break;
case HB_P_MACROPUSH:
/* compile and run - leave the result on the stack */
/* the topmost element on the stack contains a macro
* string for compilation
*/
hb_macroGetValue( hb_stackItemFromTop( -1 ), 0, pCode[ ++w ] );
w++;
break;
case HB_P_MACROPUSHLIST:
/* compile and run - leave the result on the stack */
/* the topmost element on the stack contains a macro
* string for compilation
*/
hb_macroGetValue( hb_stackItemFromTop( -1 ), HB_P_MACROPUSHLIST, pCode[ ++w ] );
w++;
break;
case HB_P_MACROPUSHINDEX:
hb_vmMacroPushIndex();
w++;
break;
case HB_P_MACROARRAYGEN:
hb_vmMacroArrayGen( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_MACRODO:
hb_vmMacroDo( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_MACROFUNC:
hb_vmMacroFunc( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_MACROSEND:
hb_vmMacroSend( HB_PCODE_MKUSHORT( &pCode[ w + 1 ] ) );
w += 3;
break;
case HB_P_MACROPUSHPARE:
/* compile and run - leave the result on the stack */
/* the topmost element on the stack contains a macro
* string for compilation
*/
hb_macroGetValue( hb_stackItemFromTop( -1 ), HB_P_MACROPUSHPARE, pCode[ ++w ] );
w++;
break;
case HB_P_MACROPUSHALIASED:
/* compile and run - leave an aliased variable on the stack */
hb_macroPushAliasedValue( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ), pCode[ ++w ] );
w++;
break;
case HB_P_MACROPUSHREF:
{
PHB_ITEM pMacro = hb_stackItemFromTop( -1 );
PHB_SYMB pSym;
/* compile into a symbol name (used in function calls) */
hb_macroPushSymbol( pMacro );
/* NOTE: pMacro string is replaced with a symbol.
* Symbol is created if it doesn't exist.
*/
if( hb_stackGetActionRequest() == 0 )
{
pSym = pMacro->item.asSymbol.value;
/* NOTE: pMacro item of symbol type is replaced with
* the reference
*/
hb_memvarGetRefer( pMacro, pSym );
}
w++;
}
break;
case HB_P_MACROSYMBOL:
/* compile into a symbol name (used in function calls) */
hb_macroPushSymbol( hb_stackItemFromTop( -1 ) );
w++;
break;
case HB_P_MACROTEXT:
/* macro text substitution
* "text ¯o.other text"
*/
hb_macroTextValue( hb_stackItemFromTop( -1 ) );
w++;
break;
/* macro compiled opcodes - we are using symbol address here */
case HB_P_MMESSAGE:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
hb_vmPushSymbol( pDynSym->pSymbol );
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPOPALIASEDFIELD:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
hb_vmPopAliasedField( pDynSym->pSymbol );
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPOPALIASEDVAR:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
hb_vmPopAliasedVar( pDynSym->pSymbol );
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPOPFIELD:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
/* Pops a value from the eval stack and uses it to set
* a new value of the given field
*/
hb_rddPutFieldValue( ( hb_stackItemFromTop(-1) ), pDynSym->pSymbol );
hb_stackPop();
HB_TRACE(HB_TR_INFO, ("(hb_vmMPopField)"));
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPOPMEMVAR:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
hb_memvarSetValue( pDynSym->pSymbol, hb_stackItemFromTop( -1 ) );
hb_stackPop();
HB_TRACE(HB_TR_INFO, ("(hb_vmMPopMemvar)"));
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPUSHALIASEDFIELD:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
hb_vmPushAliasedField( pDynSym->pSymbol );
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPUSHALIASEDVAR:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
hb_vmPushAliasedVar( pDynSym->pSymbol );
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPUSHBLOCK:
{
/*NOTE: the pcode is stored in dynamically allocated memory
* We need to handle it with more care than compile-time
* codeblocks
*/
/* +0 -> _pushblock
* +1 +2 -> size of codeblock
* +3 +4 -> number of expected parameters
* +5 -> pcode bytes
*/
ULONG ulSize = HB_PCODE_MKUSHORT( &pCode[ w + 1 ] );
hb_vmPushMacroBlock( ( BYTE * ) ( pCode + w + 5 ), ulSize - 5,
HB_PCODE_MKUSHORT( &pCode[ w + 3 ] ) );
w += ulSize;
break;
}
case HB_P_MPUSHBLOCKLARGE:
{
/*NOTE: the pcode is stored in dynamically allocated memory
* We need to handle it with more care than compile-time
* codeblocks
*/
/* +0 -> _pushblock
* +1 +2 +3 -> size of codeblock
* +4 +5 -> number of expected parameters
* +6 -> pcode bytes
*/
ULONG ulSize = HB_PCODE_MKUINT24( &pCode[ w + 1 ] );
hb_vmPushMacroBlock( ( BYTE * ) ( pCode + w + 6 ), ulSize - 6,
HB_PCODE_MKUSHORT( &pCode[ w + 4 ] ) );
w += ulSize;
break;
}
case HB_P_MPUSHFIELD:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
/* It pushes the current value of the given field onto the eval stack
*/
hb_rddGetFieldValue( hb_stackAllocItem(), pDynSym->pSymbol );
HB_TRACE(HB_TR_INFO, ("(hb_vmMPushField)"));
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPUSHMEMVAR:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
hb_memvarGetValue( hb_stackAllocItem(), pDynSym->pSymbol );
HB_TRACE(HB_TR_INFO, ("(hb_vmMPushMemvar)"));
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPUSHMEMVARREF:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
hb_memvarGetRefer( hb_stackAllocItem(), pDynSym->pSymbol );
HB_TRACE(HB_TR_INFO, ("(hb_vmMPushMemvarRef)"));
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPUSHSYM:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
hb_vmPushSymbol( pDynSym->pSymbol );
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPUSHVARIABLE:
{
HB_DYNS_PTR pDynSym = ( HB_DYNS_PTR ) HB_GET_PTR( pCode + w + 1 );
hb_vmPushVariable( pDynSym->pSymbol );
w += sizeof( HB_DYNS_PTR ) + 1;
break;
}
case HB_P_MPUSHSTR:
{
USHORT uiSize = HB_PCODE_MKUSHORT( &pCode[ w + 1 ] );
hb_vmPushString( ( char * ) ( pCode + w + 3 ), uiSize - 1 );
w += 3 + uiSize;
break;
}
case HB_P_MPUSHSTRLARGE:
{
ULONG ulSize = HB_PCODE_MKUINT24( &pCode[ w + 1 ] );
hb_vmPushString( ( char * ) ( pCode + w + 3 ), ulSize - 1 );
w += 4 + ulSize;
break;
}
case HB_P_LOCALNEARADDINT:
{
int iLocal = pCode[ w + 1 ];
HB_TRACE( HB_TR_DEBUG, ("HB_P_LOCALNEARADDINT") );
hb_vmAddInt( hb_stackLocalVariable( &iLocal ),
HB_PCODE_MKSHORT( &pCode[ w + 2 ] ) );
w += 4;
break;
}
case HB_P_LOCALADDINT:
{
int iLocal = HB_PCODE_MKUSHORT( &pCode[ w + 1 ] );
HB_TRACE( HB_TR_DEBUG, ("HB_P_LOCALADDINT") );
hb_vmAddInt( hb_stackLocalVariable( &iLocal ),
HB_PCODE_MKSHORT( &pCode[ w + 3 ] ) );
w += 5;
break;
}
case HB_P_LOCALINC:
{
int iLocal = HB_PCODE_MKUSHORT( &pCode[ w + 1 ] );
PHB_ITEM pLocal = hb_stackLocalVariable( &iLocal );
hb_vmInc( HB_IS_BYREF( pLocal ) ? hb_itemUnRef( pLocal ) : pLocal );
w += 3;
break;
}
case HB_P_LOCALDEC:
{
int iLocal = HB_PCODE_MKUSHORT( &pCode[ w + 1 ] );
PHB_ITEM pLocal = hb_stackLocalVariable( &iLocal );
hb_vmDec( HB_IS_BYREF( pLocal ) ? hb_itemUnRef( pLocal ) : pLocal );
w += 3;
break;
}
case HB_P_LOCALINCPUSH:
{
int iLocal = HB_PCODE_MKUSHORT( &pCode[ w + 1 ] );
PHB_ITEM pLocal = hb_stackLocalVariable( &iLocal );
if( HB_IS_BYREF( pLocal ) )
pLocal = hb_itemUnRef( pLocal );
hb_vmInc( pLocal );
hb_itemCopy( hb_stackAllocItem(), pLocal );
w += 3;
break;
}
/* WITH OBJECT */
case HB_P_WITHOBJECTMESSAGE:
{
USHORT wSymPos = HB_PCODE_MKUSHORT( &( pCode[ w + 1 ] ) );
if( wSymPos != 0xFFFF )
{
/* NOTE: 0xFFFF is passed when ':&varmacro' syntax is used.
* In this case symbol is already pushed on the stack
* using HB_P_MACROSYMBOL.
*/
hb_vmPushSymbol( pSymbols + wSymPos );
}
hb_vmPush( hb_stackWithObjectItem() );
w += 3;
break;
}
case HB_P_WITHOBJECTSTART:
hb_vmWithObjectStart();
w++;
break;
case HB_P_WITHOBJECTEND:
hb_stackPop(); /* remove with object envelope */
hb_stackPop(); /* remove implicit object */
w += 1;
break;
/* misc */
case HB_P_NOOP:
/* Intentionally do nothing */
w++;
break;
default:
/* TODO: Include to failing pcode in the error message */
hb_errInternal( HB_EI_VMBADOPCODE, NULL, NULL, NULL );
break;
}
if( hb_stackGetActionRequest() )
{
if( hb_stackGetActionRequest() & HB_ENDPROC_REQUESTED )
{
/* request to stop current procedure was issued
* (from macro evaluation)
*/
/* This code allow to use RETURN inside BEGIN/END sequence
* or in RECOVER code when ALWAYS clause is used
*/
if( bCanRecover )
{
do
{
hb_stackRemove( hb_stackGetRecoverBase() );
if( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.flags & HB_SEQ_DOALWAYS )
break;
/* Restore previous recovery state */
bCanRecover = ( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.flags & HB_SEQ_CANRECOVER ) != 0;
hb_stackSetRecoverBase( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.base );
}
while( bCanRecover );
/* ALWAYS found? */
if( bCanRecover )
{
/* reload the address of ALWAYS code */
w = hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.recover;
/* store and reset action */
hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.request = hb_stackGetActionRequest();
hb_stackSetActionRequest( 0 );
continue;
}
}
hb_stackSetActionRequest( 0 );
break;
}
else if( hb_stackGetActionRequest() & HB_BREAK_REQUESTED )
{
if( bCanRecover )
{
/*
* There is the BEGIN/END sequence defined in current
* procedure/function - use it to continue opcodes execution
*/
/*
* remove all items placed on the stack after BEGIN code
*/
hb_stackRemove( hb_stackGetRecoverBase() );
/*
* reload the address of recovery code
*/
w = hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.recover;
/*
* leave the SEQUENCE envelope on the stack - it will
* be popped either in RECOVER or END opcode
*/
/* store and reset action */
hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.request = hb_stackGetActionRequest();
hb_stackSetActionRequest( 0 );
}
else
break;
}
else if( hb_stackGetActionRequest() & HB_QUIT_REQUESTED )
{
if( bCanRecover )
{
do
{
hb_stackRemove( hb_stackGetRecoverBase() );
if( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.flags & HB_SEQ_DOALWAYS )
break;
/* Restore previous recovery state */
bCanRecover = ( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.flags & HB_SEQ_CANRECOVER ) != 0;
hb_stackSetRecoverBase( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.base );
/* skip other steps */
}
while( bCanRecover );
/* ALWAYS found? */
if( bCanRecover )
{
/* reload the address of ALWAYS code */
w = hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.recover;
/* store and reset action */
hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.request = hb_stackGetActionRequest();
hb_stackSetActionRequest( 0 );
continue;
}
}
break;
}
}
}
}
/* ------------------------------- */
/* Operators ( mathematical */
/* character / misc ) */
| hvm.c | 560 |
STATIC VOID | hb_vmAddInt( HB_ITEM_PTR pResult, LONG lAdd )
static void hb_vmAddInt( HB_ITEM_PTR pResult, LONG lAdd )
{
double dNewVal;
HB_TRACE(HB_TR_DEBUG, ("hb_vmAddInt(%p,%ld)", pResult, lAdd));
if( HB_IS_BYREF( pResult ) )
{
pResult = hb_itemUnRef( pResult );
}
if( HB_IS_NUMINT( pResult ) )
{
HB_LONG lVal = HB_ITEM_GET_NUMINTRAW( pResult ), lResult;
lResult = lVal + lAdd;
if( lAdd >= 0 ? lResult >= lVal : lResult < lVal )
{
HB_ITEM_PUT_NUMINTRAW( pResult, lResult );
return;
}
else
{
dNewVal = ( double ) lVal + lAdd;
}
}
else if( HB_IS_DATE( pResult ) )
{
pResult->item.asDate.value += lAdd;
return;
}
else if( HB_IS_DOUBLE( pResult ) )
{
dNewVal = pResult->item.asDouble.value + lAdd;
}
else if( hb_objHasOperator( pResult, HB_OO_OP_PLUS ) )
{
hb_vmPushLong( lAdd );
hb_objOperatorCall( HB_OO_OP_PLUS, pResult, pResult, hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
return;
}
else
{
PHB_ITEM pSubst;
hb_vmPushLong( lAdd );
pSubst = hb_errRT_BASE_Subst( EG_ARG, 1081, NULL, "+", 2, pResult, hb_stackItemFromTop( -1 ) );
if( pSubst )
{
hb_stackPop();
hb_itemMove( pResult, pSubst );
hb_itemRelease( pSubst );
}
return;
}
if( !HB_IS_DOUBLE( pResult ) )
{
pResult->type = HB_IT_DOUBLE;
pResult->item.asDouble.decimal = 0;
}
pResult->item.asDouble.value = dNewVal;
pResult->item.asDouble.length = HB_DBL_LENGTH( dNewVal );
}
| hvm.c | 2253 |
STATIC VOID | hb_vmNegate( void )
static void hb_vmNegate( void )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_vmNegate()"));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_INTEGER( pItem ) )
{
#if -HB_INT_MAX > HB_INT_MIN
if( pItem->item.asInteger.value < -HB_INT_MAX )
{
#if HB_LONG_MAX > HB_INT_MAX
HB_LONG lValue = ( HB_LONG ) pItem->item.asInteger.value;
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = -lValue;
pItem->item.asLong.length = HB_LONG_EXPLENGTH( -lValue );
#else
double dValue = ( double ) pItem->item.asInteger.value;
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value = -dValue;
pItem->item.asDouble.length = HB_DBL_LENGTH( -dValue );
#endif
}
else
#endif
{
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = -pItem->item.asInteger.value;
pItem->item.asInteger.length = HB_INT_EXPLENGTH( pItem->item.asInteger.value );
}
}
else if( HB_IS_LONG( pItem ) )
{
#if -HB_LONG_MAX > HB_LONG_MIN
if( pItem->item.asLong.value < -HB_LONG_MAX )
{
double dValue = ( double ) pItem->item.asLong.value;
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value = -dValue;
pItem->item.asDouble.length = HB_DBL_LENGTH( -dValue );
}
else
#endif
{
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = -pItem->item.asLong.value;
pItem->item.asLong.length = HB_LONG_EXPLENGTH( pItem->item.asLong.value );
}
}
else if( HB_IS_DOUBLE( pItem ) )
{
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value = -pItem->item.asDouble.value;
pItem->item.asDouble.length = HB_DBL_LENGTH( pItem->item.asDouble.value );
}
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1080, NULL, "-", 1, pItem );
if( pResult )
{
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 2323 |
STATIC VOID | hb_vmPlus( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
static void hb_vmPlus( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmPlus(%p,%p,%p)", pResult, pItem1, pItem2));
if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
HB_LONG lNumber1 = HB_ITEM_GET_NUMINTRAW( pItem1 );
HB_LONG lNumber2 = HB_ITEM_GET_NUMINTRAW( pItem2 );
HB_LONG lResult = lNumber1 + lNumber2;
if( lNumber2 >= 0 ? lResult >= lNumber1 : lResult < lNumber1 )
{
HB_ITEM_PUT_NUMINTRAW( pResult, lResult );
}
else
{
hb_itemPutND( pResult, ( double ) lNumber1 + ( double ) lNumber2 );
}
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
int iDec1, iDec2;
double dNumber1 = hb_itemGetNDDec( pItem1, &iDec1 );
double dNumber2 = hb_itemGetNDDec( pItem2, &iDec2 );
hb_itemPutNumType( pResult, dNumber1 + dNumber2, HB_MAX( iDec1, iDec2 ),
HB_ITEM_TYPERAW( pItem1 ), HB_ITEM_TYPERAW( pItem2 ) );
}
else if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) )
{
ULONG ulLen1 = pItem1->item.asString.length;
ULONG ulLen2 = pItem2->item.asString.length;
if( ulLen2 )
{
if( ulLen1 )
{
if( ulLen1 < ULONG_MAX - ulLen2 )
{
if( pResult != pItem1 )
{
hb_itemMove( pResult, pItem1 );
pItem1 = pResult;
}
hb_itemReSizeString( pItem1, ulLen1 + ulLen2 );
hb_xmemcpy( pItem1->item.asString.value + ulLen1,
pItem2->item.asString.value, ulLen2 );
}
else
hb_errRT_BASE( EG_STROVERFLOW, 1209, NULL, "+", 2, pItem1, pItem2 );
}
else
hb_itemCopy( pResult, pItem2 );
}
else if( pResult != pItem1 )
hb_itemCopy( pResult, pItem1 );
pResult->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT );
}
else if( HB_IS_DATE( pItem1 ) && HB_IS_DATE( pItem2 ) )
{
/* NOTE: This is not a bug. CA-Cl*pper does exactly that. */
hb_itemPutDL( pResult, hb_itemGetNL( pItem1 ) + hb_itemGetNL( pItem2 ) );
}
else if( HB_IS_DATE( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
hb_itemPutDL( pResult, hb_itemGetDL( pItem1 ) + hb_itemGetNL( pItem2 ) );
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_DATE( pItem2 ) )
{
hb_itemPutDL( pResult, hb_itemGetNL( pItem1 ) + hb_itemGetDL( pItem2 ) );
}
else if( ! hb_objOperatorCall( HB_OO_OP_PLUS, pResult, pItem1, pItem2, NULL ) )
{
PHB_ITEM pSubst = hb_errRT_BASE_Subst( EG_ARG, 1081, NULL, "+", 2, pItem1, pItem2 );
if( pSubst )
{
hb_itemMove( pResult, pSubst );
hb_itemRelease( pSubst );
}
}
}
| hvm.c | 2392 |
STATIC VOID | hb_vmMinus( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
static void hb_vmMinus( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmMinus(%p,%p,%p)", pResult, pItem1, pItem2));
if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
HB_LONG lNumber1 = HB_ITEM_GET_NUMINTRAW( pItem1 );
HB_LONG lNumber2 = HB_ITEM_GET_NUMINTRAW( pItem2 );
HB_LONG lResult = lNumber1 - lNumber2;
if( lNumber2 <= 0 ? lResult >= lNumber1 : lResult < lNumber1 )
{
HB_ITEM_PUT_NUMINTRAW( pResult, lResult );
}
else
{
hb_itemPutND( pResult, ( double ) lNumber1 - ( double ) lNumber2 );
}
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
int iDec1, iDec2;
double dNumber1 = hb_itemGetNDDec( pItem1, &iDec1 );
double dNumber2 = hb_itemGetNDDec( pItem2, &iDec2 );
hb_itemPutNumType( pResult, dNumber1 - dNumber2, HB_MAX( iDec1, iDec2 ),
HB_ITEM_TYPERAW( pItem1 ), HB_ITEM_TYPERAW( pItem2 ) );
}
else if( HB_IS_DATE( pItem1 ) && HB_IS_DATE( pItem2 ) )
{
HB_LONG lResult = hb_itemGetDL( pItem1 ) - hb_itemGetDL( pItem2 );
HB_ITEM_PUT_NUMINTRAW( pResult, lResult );
}
else if( HB_IS_DATE( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
hb_itemPutDL( pResult, hb_itemGetDL( pItem1 ) - hb_itemGetNL( pItem2 ) );
}
else if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) )
{
ULONG ulLen1 = pItem1->item.asString.length;
ULONG ulLen2 = pItem2->item.asString.length;
if( ulLen1 == 0 )
{
hb_itemCopy( pResult, pItem2 );
pResult->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT );
}
else if( ulLen2 == 0 )
{
if( pResult != pItem1 )
hb_itemCopy( pResult, pItem1 );
pResult->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT );
}
else if( ulLen1 < ULONG_MAX - ulLen2 )
{
if( pResult != pItem1 )
{
hb_itemMove( pResult, pItem1 );
pItem1 = pResult;
}
hb_itemReSizeString( pItem1, ulLen1 + ulLen2 );
while( ulLen1 && pItem1->item.asString.value[ ulLen1 - 1 ] == ' ' )
ulLen1--;
hb_xmemcpy( pItem1->item.asString.value + ulLen1,
pItem2->item.asString.value, ulLen2 );
hb_xmemset( pItem1->item.asString.value + ulLen1 + ulLen2, ' ',
pItem1->item.asString.length - ulLen1 - ulLen2 );
}
else
hb_errRT_BASE( EG_STROVERFLOW, 1210, NULL, "-", 2, pItem1, pItem2 );
}
else if( ! hb_objOperatorCall( HB_OO_OP_MINUS, pResult, pItem1, pItem2, NULL ) )
{
PHB_ITEM pSubst = hb_errRT_BASE_Subst( EG_ARG, 1082, NULL, "-", 2, pItem1, pItem2 );
if( pSubst )
{
hb_itemMove( pResult, pSubst );
hb_itemRelease( pSubst );
}
}
}
| hvm.c | 2475 |
STATIC VOID | hb_vmMult( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
static void hb_vmMult( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmMult(%p,%p,%p)", pResult, pItem1, pItem2));
/* if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
HB_LONG lNumber1 = HB_ITEM_GET_NUMINTRAW( pItem1 )
HB_LONG lNumber2 = HB_ITEM_GET_NUMINTRAW( pItem2 );
HB_LONG lResult = lNumber1 * lNumber2;
if( lNumber2 == 0 || lResult / lNumber2 == lNumber1 )
HB_ITEM_PUT_NUMINTRAW( pResult, lResult );
else
hb_itemPutNLen( pResult, ( double ) lNumber1 * lNumber2, 0, 0 );
}
else */ if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
int iDec1, iDec2;
double dNumber1 = hb_itemGetNDDec( pItem1, &iDec1 );
double dNumber2 = hb_itemGetNDDec( pItem2, &iDec2 );
hb_itemPutNumType( pResult, dNumber1 * dNumber2, iDec1 + iDec2,
HB_ITEM_TYPERAW( pItem1 ), HB_ITEM_TYPERAW( pItem2 ) );
}
else if( ! hb_objOperatorCall( HB_OO_OP_MULT, pResult, pItem1, pItem2, NULL ) )
{
PHB_ITEM pSubst = hb_errRT_BASE_Subst( EG_ARG, 1083, NULL, "*", 2, pItem1, pItem2 );
if( pSubst )
{
hb_itemMove( pResult, pSubst );
hb_itemRelease( pSubst );
}
}
}
| hvm.c | 2559 |
STATIC VOID | hb_vmDivide( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
static void hb_vmDivide( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmDivide(%p,%p,%p)", pResult, pItem1, pItem2));
if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
HB_LONG lDivisor = HB_ITEM_GET_NUMINTRAW( pItem2 );
if( lDivisor == 0 )
{
PHB_ITEM pSubst = hb_errRT_BASE_Subst( EG_ZERODIV, 1340, NULL, "/", 2, pItem1, pItem2 );
if( pSubst )
{
hb_itemMove( pResult, pSubst );
hb_itemRelease( pSubst );
}
}
else
{
HB_LONG lNumber1 = HB_ITEM_GET_NUMINTRAW( pItem1 );
hb_itemPutND( pResult, ( double ) lNumber1 / ( double ) lDivisor );
}
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
double dDivisor = hb_itemGetND( pItem2 );
if( dDivisor == 0.0 )
{
PHB_ITEM pSubst = hb_errRT_BASE_Subst( EG_ZERODIV, 1340, NULL, "/", 2, pItem1, pItem2 );
if( pSubst )
{
hb_itemMove( pResult, pSubst );
hb_itemRelease( pSubst );
}
}
else
{
/* If all both operand was integer and the result is an integer, too,
push the number without decimals. Clipper compatible. Actually,
this is not Clipper compatible. The only time Clipper returns 0
decimal places is for compiler optimized integer division with an
integer result. Therefore this code is not needed and has been
removed - David G. Holm
*/
hb_itemPutND( pResult, hb_itemGetND( pItem1 ) / dDivisor );
}
}
else if( ! hb_objOperatorCall( HB_OO_OP_DIVIDE, pResult, pItem1, pItem2, NULL ) )
{
PHB_ITEM pSubst = hb_errRT_BASE_Subst( EG_ARG, 1084, NULL, "/", 2, pItem1, pItem2 );
if( pSubst )
{
hb_itemMove( pResult, pSubst );
hb_itemRelease( pSubst );
}
}
}
| hvm.c | 2595 |
STATIC VOID | hb_vmModulus( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
static void hb_vmModulus( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmModulus(%p,%p,%p)", pResult, pItem1, pItem2));
if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
HB_LONG lDivisor = HB_ITEM_GET_NUMINTRAW( pItem2 );
if( lDivisor == 0 )
{
PHB_ITEM pSubst = hb_errRT_BASE_Subst( EG_ZERODIV, 1341, NULL, "%", 2, pItem1, pItem2 );
if( pSubst )
{
hb_itemMove( pResult, pSubst );
hb_itemRelease( pSubst );
}
}
else
{
/* NOTE: Clipper always returns the result of modulus
with the SET number of decimal places. */
if( hb_set.HB_SET_DECIMALS == 0 )
{
lDivisor = HB_ITEM_GET_NUMINTRAW( pItem1 ) % lDivisor;
HB_ITEM_PUT_NUMINTRAW( pResult, lDivisor );
}
else
hb_itemPutND( pResult, ( double ) ( HB_ITEM_GET_NUMINTRAW( pItem1 ) % lDivisor ) );
}
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
double dDivisor = hb_itemGetND( pItem2 );
if( dDivisor == 0.0 )
{
PHB_ITEM pSubst = hb_errRT_BASE_Subst( EG_ZERODIV, 1341, NULL, "%", 2, pItem1, pItem2 );
if( pSubst )
{
hb_itemMove( pResult, pSubst );
hb_itemRelease( pSubst );
}
}
else
{
/* NOTE: Clipper always returns the result of modulus
with the SET number of decimal places. */
hb_itemPutND( pResult, fmod( hb_itemGetND( pItem1 ), dDivisor ) );
}
}
else if( ! hb_objOperatorCall( HB_OO_OP_MOD, pResult, pItem1, pItem2, NULL ) )
{
PHB_ITEM pSubst = hb_errRT_BASE_Subst( EG_ARG, 1085, NULL, "%", 2, pItem1, pItem2 );
if( pSubst )
{
hb_itemMove( pResult, pSubst );
hb_itemRelease( pSubst );
}
}
}
| hvm.c | 2657 |
STATIC VOID | hb_vmPower( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
static void hb_vmPower( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pItem2 )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmPower(%p,%p,%p)", pResult, pItem1, pItem2));
if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
/* NOTE: Clipper always returns the result of power
with the SET number of decimal places. */
hb_itemPutND( pResult, pow( hb_itemGetND( pItem1 ), hb_itemGetND( pItem2 ) ) );
}
else if( ! hb_objOperatorCall( HB_OO_OP_POWER, pResult, pItem1, pItem2, NULL ) )
{
PHB_ITEM pSubst = hb_errRT_BASE_Subst( EG_ARG, 1088, NULL, "^", 2, pItem1, pItem2 );
if( pSubst )
{
hb_itemMove( pResult, pSubst );
hb_itemRelease( pSubst );
}
}
}
| hvm.c | 2721 |
STATIC VOID | hb_vmInc( PHB_ITEM pItem )
static void hb_vmInc( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmInc(%p)", pItem));
if( HB_IS_NUMINT( pItem ) )
{
if( HB_IS_INTEGER( pItem ) )
{
if( pItem->item.asInteger.value < HB_INT_MAX )
{
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value++;
pItem->item.asInteger.length = HB_INT_EXPLENGTH( pItem->item.asInteger.value );
}
else
{
#if HB_INT_MAX < HB_LONG_MAX
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = ( HB_LONG ) pItem->item.asInteger.value + 1;
pItem->item.asLong.length = HB_LONG_EXPLENGTH( pItem->item.asLong.value );
#else
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value = ( double ) pItem->item.asInteger.value + 1;
pItem->item.asDouble.length = HB_DBL_LENGTH( pItem->item.asDouble.value );
pItem->item.asDouble.decimal = 0;
#endif
}
}
else if( pItem->item.asLong.value < HB_LONG_MAX )
{
pItem->type = HB_IT_LONG;
pItem->item.asLong.value++;
pItem->item.asLong.length = HB_LONG_EXPLENGTH( pItem->item.asLong.value );
}
else
{
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value = ( double ) pItem->item.asLong.value + 1;
pItem->item.asDouble.length = HB_DBL_LENGTH( pItem->item.asDouble.value );
pItem->item.asDouble.decimal = 0;
}
}
else if( HB_IS_DOUBLE( pItem ) )
{
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value++;
pItem->item.asDouble.length = HB_DBL_LENGTH( pItem->item.asDouble.value );
}
else if( HB_IS_DATE( pItem ) )
{
pItem->type = HB_IT_DATE;
pItem->item.asDate.value++;
}
else if( ! hb_objOperatorCall( HB_OO_OP_INC, pItem, pItem, NULL, NULL ) )
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1086, NULL, "++", 1, pItem );
if( pResult )
{
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 2743 |
STATIC VOID | hb_vmDec( PHB_ITEM pItem )
static void hb_vmDec( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmDec(%p)", pItem));
if( HB_IS_NUMINT( pItem ) )
{
if( HB_IS_INTEGER( pItem ) )
{
if( pItem->item.asInteger.value > HB_INT_MIN )
{
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value--;
pItem->item.asInteger.length = HB_INT_EXPLENGTH( pItem->item.asInteger.value );
}
else
{
#if HB_INT_MIN > HB_LONG_MIN
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = ( HB_LONG ) pItem->item.asInteger.value - 1;
pItem->item.asLong.length = HB_LONG_EXPLENGTH( pItem->item.asLong.value );
#else
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value = ( double ) pItem->item.asInteger.value - 1;
pItem->item.asDouble.length = HB_DBL_LENGTH( pItem->item.asDouble.value );
pItem->item.asDouble.decimal = 0;
#endif
}
}
else if( pItem->item.asLong.value > HB_LONG_MIN )
{
pItem->type = HB_IT_LONG;
pItem->item.asLong.value--;
pItem->item.asLong.length = HB_LONG_EXPLENGTH( pItem->item.asLong.value );
}
else
{
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value = ( double ) pItem->item.asLong.value - 1;
pItem->item.asDouble.length = HB_DBL_LENGTH( pItem->item.asDouble.value );
pItem->item.asDouble.decimal = 0;
}
}
else if( HB_IS_DOUBLE( pItem ) )
{
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value--;
pItem->item.asDouble.length = HB_DBL_LENGTH( pItem->item.asDouble.value );
}
else if( HB_IS_DATE( pItem ) )
{
pItem->type = HB_IT_DATE;
pItem->item.asDate.value--;
}
else if( ! hb_objOperatorCall( HB_OO_OP_DEC, pItem, pItem, NULL, NULL ) )
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1087, NULL, "--", 1, pItem );
if( pResult )
{
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 2808 |
STATIC VOID | hb_vmFuncPtr( void )
static void hb_vmFuncPtr( void ) /* pushes a function address pointer. Removes the symbol from the satck */
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_vmFuncPtr()"));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_SYMBOL( pItem ) )
{
/* do nothing - now we are using HB_IT_SYMBOL */
#if 0
hb_stackPop();
hb_vmPushPointer( ( void* ) pItem->item.asSymbol.value->value.pFunPtr );
#endif
}
else
hb_errInternal( HB_EI_VMNOTSYMBOL, NULL, "hb_vmFuncPtr()", NULL );
}
/* ------------------------------- */
/* Operators (relational) */
| hvm.c | 2873 |
STATIC VOID | hb_vmExactlyEqual( void )
static void hb_vmExactlyEqual( void )
{
PHB_ITEM pItem2;
PHB_ITEM pItem1;
HB_TRACE(HB_TR_DEBUG, ("hb_vmExactlyEqual()"));
pItem2 = hb_stackItemFromTop( -1 );
pItem1 = hb_stackItemFromTop( -2 );
if( HB_IS_NIL( pItem1 ) )
{
/* pItem1 is NIL so this is safe */
pItem1->type = HB_IT_LOGICAL;
pItem1->item.asLogical.value = HB_IS_NIL( pItem2 );
hb_stackPop(); /* clear the pItem2 */
}
else if( HB_IS_NIL( pItem2 ) )
{
hb_stackDec(); /* pItem2 is already NIL */
hb_stackPop(); /* clear the pItem1 */
hb_vmPushLogical( FALSE );
}
else if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) )
{
BOOL fResult = pItem1->item.asString.length == pItem2->item.asString.length &&
memcmp( pItem1->item.asString.value,
pItem2->item.asString.value,
pItem1->item.asString.length ) == 0;
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( fResult );
}
else if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
pItem1->item.asLogical.value = ( HB_ITEM_GET_NUMINTRAW( pItem1 ) ==
HB_ITEM_GET_NUMINTRAW( pItem2 ) );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
hb_vmPushLogical( hb_vmPopNumber() == hb_vmPopNumber() );
else if( HB_IS_DATE( pItem1 ) && HB_IS_DATE( pItem2 ) )
{
pItem1->item.asLogical.value = ( pItem1->item.asDate.value ==
pItem2->item.asDate.value );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_LOGICAL( pItem1 ) && HB_IS_LOGICAL( pItem2 ) )
hb_vmPushLogical( hb_vmPopLogical() == hb_vmPopLogical() );
else if( HB_IS_POINTER( pItem1 ) && HB_IS_POINTER( pItem2 ) )
{
BOOL fResult = pItem1->item.asPointer.value == pItem2->item.asPointer.value;
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( fResult );
}
else if( HB_IS_HASH( pItem1 ) && HB_IS_HASH( pItem2 ) )
{
BOOL fResult = pItem1->item.asHash.value == pItem2->item.asHash.value;
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( fResult );
}
else if( HB_IS_ARRAY( pItem1 ) && HB_IS_ARRAY( pItem2 ) &&
! hb_objHasOperator( pItem1, HB_OO_OP_EXACTEQUAL ) )
{
BOOL fResult = pItem1->item.asArray.value == pItem2->item.asArray.value;
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( fResult );
}
else if( hb_objOperatorCall( HB_OO_OP_EXACTEQUAL, pItem1, pItem1, pItem2, NULL ) )
hb_stackPop();
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1070, NULL, "==", 2, pItem1, pItem2 );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem1, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 2897 |
STATIC VOID | hb_vmEqual( void )
static void hb_vmEqual( void )
{
PHB_ITEM pItem2;
PHB_ITEM pItem1;
HB_TRACE(HB_TR_DEBUG, ("hb_vmEqual()"));
pItem2 = hb_stackItemFromTop( -1 );
pItem1 = hb_stackItemFromTop( -2 );
if( HB_IS_NIL( pItem1 ) )
{
/* pItem1 is NIL so this is safe */
pItem1->type = HB_IT_LOGICAL;
pItem1->item.asLogical.value = HB_IS_NIL( pItem2 );
hb_stackPop(); /* clear the pItem2 */
}
else if( HB_IS_NIL( pItem2 ) )
{
hb_stackDec(); /* pItem2 is already NIL */
hb_stackPop(); /* clear the pItem1 */
hb_vmPushLogical( FALSE );
}
else if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) )
{
BOOL fResult = hb_itemStrCmp( pItem1, pItem2, FALSE ) == 0;
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( fResult );
}
else if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
pItem1->item.asLogical.value = ( HB_ITEM_GET_NUMINTRAW( pItem1 ) ==
HB_ITEM_GET_NUMINTRAW( pItem2 ) );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
hb_vmPushLogical( hb_vmPopNumber() == hb_vmPopNumber() );
else if( HB_IS_DATE( pItem1 ) && HB_IS_DATE( pItem2 ) )
{
pItem1->item.asLogical.value = ( pItem1->item.asDate.value ==
pItem2->item.asDate.value );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_LOGICAL( pItem1 ) && HB_IS_LOGICAL( pItem2 ) )
hb_vmPushLogical( hb_vmPopLogical() == hb_vmPopLogical() );
else if( HB_IS_POINTER( pItem1 ) && HB_IS_POINTER( pItem2 ) )
{
BOOL fResult = pItem1->item.asPointer.value == pItem2->item.asPointer.value;
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( fResult );
}
else if( HB_IS_HASH( pItem1 ) && HB_IS_HASH( pItem2 ) )
{
BOOL fResult = pItem1->item.asHash.value == pItem2->item.asHash.value;
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( fResult );
}
else if( hb_objOperatorCall( HB_OO_OP_EQUAL, pItem1, pItem1, pItem2, NULL ) )
hb_stackPop();
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1071, NULL, "=", 2, pItem1, pItem2 );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem1, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 2987 |
STATIC VOID | hb_vmNotEqual( void )
static void hb_vmNotEqual( void )
{
PHB_ITEM pItem2;
PHB_ITEM pItem1;
HB_TRACE(HB_TR_DEBUG, ("hb_vmNotEqual()"));
pItem2 = hb_stackItemFromTop( -1 );
pItem1 = hb_stackItemFromTop( -2 );
if( HB_IS_NIL( pItem1 ) )
{
/* pItem1 is NIL so this is safe */
pItem1->type = HB_IT_LOGICAL;
pItem1->item.asLogical.value = ! HB_IS_NIL( pItem2 );
hb_stackPop(); /* clear the pItem2 */
}
else if( HB_IS_NIL( pItem2 ) )
{
hb_stackDec(); /* pItem2 is already NIL */
hb_stackPop(); /* clear the pItem1 */
hb_vmPushLogical( TRUE );
}
else if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) )
{
int i = hb_itemStrCmp( pItem1, pItem2, FALSE );
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( i != 0 );
}
else if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
pItem1->item.asLogical.value = ( HB_ITEM_GET_NUMINTRAW( pItem1 ) !=
HB_ITEM_GET_NUMINTRAW( pItem2 ) );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
hb_vmPushLogical( hb_vmPopNumber() != hb_vmPopNumber() );
else if( HB_IS_DATE( pItem1 ) && HB_IS_DATE( pItem2 ) )
{
pItem1->item.asLogical.value = ( pItem1->item.asDate.value !=
pItem2->item.asDate.value );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_LOGICAL( pItem1 ) && HB_IS_LOGICAL( pItem2 ) )
hb_vmPushLogical( hb_vmPopLogical() != hb_vmPopLogical() );
else if( HB_IS_POINTER( pItem1 ) && HB_IS_POINTER( pItem2 ) )
{
BOOL fValue = pItem1->item.asPointer.value !=
pItem2->item.asPointer.value;
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( fValue );
}
else if( HB_IS_HASH( pItem1 ) && HB_IS_HASH( pItem2 ) )
{
BOOL fResult = pItem1->item.asHash.value != pItem2->item.asHash.value;
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( fResult );
}
else if( hb_objOperatorCall( HB_OO_OP_NOTEQUAL, pItem1, pItem1, pItem2, NULL ) )
hb_stackPop();
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1072, NULL, "<>", 2, pItem1, pItem2 );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem1, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 3063 |
STATIC VOID | hb_vmLess( void )
static void hb_vmLess( void )
{
PHB_ITEM pItem2;
PHB_ITEM pItem1;
HB_TRACE(HB_TR_DEBUG, ("hb_vmLess()"));
pItem2 = hb_stackItemFromTop( -1 );
pItem1 = hb_stackItemFromTop( -2 );
if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) )
{
int i = hb_itemStrCmp( pItem1, pItem2, FALSE );
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( i < 0 );
}
else if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
pItem1->item.asLogical.value = ( HB_ITEM_GET_NUMINTRAW( pItem1 ) <
HB_ITEM_GET_NUMINTRAW( pItem2 ) );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
double dNumber2 = hb_vmPopNumber();
double dNumber1 = hb_vmPopNumber();
hb_vmPushLogical( dNumber1 < dNumber2 );
}
else if( HB_IS_DATE( pItem1 ) && HB_IS_DATE( pItem2 ) )
{
pItem1->item.asLogical.value = ( pItem1->item.asDate.value <
pItem2->item.asDate.value );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_LOGICAL( pItem1 ) && HB_IS_LOGICAL( pItem2 ) )
{
BOOL bLogical2 = hb_vmPopLogical();
BOOL bLogical1 = hb_vmPopLogical();
hb_vmPushLogical( bLogical1 < bLogical2 );
}
else if( hb_objOperatorCall( HB_OO_OP_LESS, pItem1, pItem1, pItem2, NULL ) )
hb_stackPop();
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1073, NULL, "<", 2, pItem1, pItem2 );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem1, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 3141 |
STATIC VOID | hb_vmLessEqual( void )
static void hb_vmLessEqual( void )
{
PHB_ITEM pItem2;
PHB_ITEM pItem1;
HB_TRACE(HB_TR_DEBUG, ("hb_vmLessEqual()"));
pItem2 = hb_stackItemFromTop( -1 );
pItem1 = hb_stackItemFromTop( -2 );
if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) )
{
int i = hb_itemStrCmp( pItem1, pItem2, FALSE );
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( i <= 0 );
}
else if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
pItem1->item.asLogical.value = ( HB_ITEM_GET_NUMINTRAW( pItem1 ) <=
HB_ITEM_GET_NUMINTRAW( pItem2 ) );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
double dNumber2 = hb_vmPopNumber();
double dNumber1 = hb_vmPopNumber();
hb_vmPushLogical( dNumber1 <= dNumber2 );
}
else if( HB_IS_DATE( pItem1 ) && HB_IS_DATE( pItem2 ) )
{
pItem1->item.asLogical.value = ( pItem1->item.asDate.value <=
pItem2->item.asDate.value );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_LOGICAL( pItem1 ) && HB_IS_LOGICAL( pItem2 ) )
{
BOOL bLogical2 = hb_vmPopLogical();
BOOL bLogical1 = hb_vmPopLogical();
hb_vmPushLogical( bLogical1 <= bLogical2 );
}
else if( hb_objOperatorCall( HB_OO_OP_LESSEQUAL, pItem1, pItem1, pItem2, NULL ) )
hb_stackPop();
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1074, NULL, "<=", 2, pItem1, pItem2 );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem1, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 3200 |
STATIC VOID | hb_vmGreater( void )
static void hb_vmGreater( void )
{
PHB_ITEM pItem2;
PHB_ITEM pItem1;
HB_TRACE(HB_TR_DEBUG, ("hb_vmGreater()"));
pItem2 = hb_stackItemFromTop( -1 );
pItem1 = hb_stackItemFromTop( -2 );
if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) )
{
int i = hb_itemStrCmp( pItem1, pItem2, FALSE );
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( i > 0 );
}
else if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
pItem1->item.asLogical.value = ( HB_ITEM_GET_NUMINTRAW( pItem1 ) >
HB_ITEM_GET_NUMINTRAW( pItem2 ) );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
double dNumber2 = hb_vmPopNumber();
double dNumber1 = hb_vmPopNumber();
hb_vmPushLogical( dNumber1 > dNumber2 );
}
else if( HB_IS_DATE( pItem1 ) && HB_IS_DATE( pItem2 ) )
{
pItem1->item.asLogical.value = ( pItem1->item.asDate.value >
pItem2->item.asDate.value );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_LOGICAL( pItem1 ) && HB_IS_LOGICAL( pItem2 ) )
{
BOOL bLogical2 = hb_vmPopLogical();
BOOL bLogical1 = hb_vmPopLogical();
hb_vmPushLogical( bLogical1 > bLogical2 );
}
else if( hb_objOperatorCall( HB_OO_OP_GREATER, pItem1, pItem1, pItem2, NULL ) )
hb_stackPop();
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1075, NULL, ">", 2, pItem1, pItem2 );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem1, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 3259 |
STATIC VOID | hb_vmGreaterEqual( void )
static void hb_vmGreaterEqual( void )
{
PHB_ITEM pItem2;
PHB_ITEM pItem1;
HB_TRACE(HB_TR_DEBUG, ("hb_vmGreaterEqual()"));
pItem2 = hb_stackItemFromTop( -1 );
pItem1 = hb_stackItemFromTop( -2 );
if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) )
{
int i = hb_itemStrCmp( pItem1, pItem2, FALSE );
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( i >= 0 );
}
else if( HB_IS_NUMINT( pItem1 ) && HB_IS_NUMINT( pItem2 ) )
{
pItem1->item.asLogical.value = ( HB_ITEM_GET_NUMINTRAW( pItem1 ) >=
HB_ITEM_GET_NUMINTRAW( pItem2 ) );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem1 ) && HB_IS_NUMERIC( pItem2 ) )
{
double dNumber2 = hb_vmPopNumber();
double dNumber1 = hb_vmPopNumber();
hb_vmPushLogical( dNumber1 >= dNumber2 );
}
else if( HB_IS_DATE( pItem1 ) && HB_IS_DATE( pItem2 ) )
{
pItem1->item.asLogical.value = ( pItem1->item.asDate.value >=
pItem2->item.asDate.value );
pItem1->type = HB_IT_LOGICAL;
hb_stackDec();
}
else if( HB_IS_LOGICAL( pItem1 ) && HB_IS_LOGICAL( pItem2 ) )
{
BOOL bLogical2 = hb_vmPopLogical();
BOOL bLogical1 = hb_vmPopLogical();
hb_vmPushLogical( bLogical1 >= bLogical2 );
}
else if( hb_objOperatorCall( HB_OO_OP_GREATEREQUAL, pItem1, pItem1, pItem2, NULL ) )
hb_stackPop();
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1076, NULL, ">=", 2, pItem1, pItem2 );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem1, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 3318 |
STATIC VOID | hb_vmInstring( void )
static void hb_vmInstring( void )
{
PHB_ITEM pItem1;
PHB_ITEM pItem2;
HB_TRACE(HB_TR_DEBUG, ("hb_vmInstring()"));
pItem1 = hb_stackItemFromTop( -2 );
pItem2 = hb_stackItemFromTop( -1 );
if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) )
{
BOOL fResult = ( hb_strAt( pItem1->item.asString.value, pItem1->item.asString.length,
pItem2->item.asString.value, pItem2->item.asString.length ) != 0 );
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( fResult );
}
else if( HB_IS_HASH( pItem2 ) &&
( HB_IS_HASHKEY( pItem1 ) || hb_hashLen( pItem1 ) == 1 ) )
{
BOOL fResult = hb_hashScan( pItem2, pItem1, NULL );
hb_stackPop();
hb_stackPop();
hb_vmPushLogical( fResult );
}
else if( hb_objOperatorCall( HB_OO_OP_INCLUDE, pItem1, pItem2, pItem1, NULL ) )
hb_stackPop();
else if( hb_objOperatorCall( HB_OO_OP_INSTRING, pItem1, pItem1, pItem2, NULL ) )
hb_stackPop();
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1109, NULL, "$", 2, pItem1, pItem2 );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem1, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 3377 |
STATIC VOID | hb_vmForTest( void )
static void hb_vmForTest( void ) /* Test to check the end point of the FOR */
{
BOOL fBack;
HB_TRACE(HB_TR_DEBUG, ("hb_vmForTest()"));
if( HB_IS_NUMERIC( hb_stackItemFromTop( -1 ) ) )
{
fBack = hb_vmPopNumber() < 0.0;
}
else
{
PHB_ITEM pResult;
hb_vmPushInteger( 0 );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1073, NULL, "<", 2, hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
if( pResult )
{
if( HB_IS_LOGICAL( pResult ) )
{
fBack = pResult->item.asLogical.value;
hb_itemRelease( pResult );
hb_stackPop();
hb_stackPop();
}
else
{
hb_itemMove( hb_stackItemFromTop( -1 ), pResult );
hb_itemRelease( pResult );
hb_errRT_BASE( EG_ARG, 1066, NULL, hb_langDGetErrorDesc( EG_CONDITION ), 1, hb_stackItemFromTop( -1 ) );
return;
}
}
else
return;
}
if( fBack )
hb_vmLess();
else
hb_vmGreater();
}
| hvm.c | 3423 |
STATIC HB_GARBAGE_FUNC( | hb_SeqBlockDestructor )
static HB_GARBAGE_FUNC( hb_SeqBlockDestructor )
{
PHB_ITEM * pBlockPtr = ( PHB_ITEM * ) Cargo;
hb_itemMove( hb_errorBlock(), * pBlockPtr );
hb_itemRelease( * pBlockPtr );
}
| hvm.c | 3472 |
STATIC VOID | hb_vmSeqBlock( void )
static void hb_vmSeqBlock( void )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_vmSeqBlock()"));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_BLOCK( pItem ) )
{
PHB_ITEM * pBlockPtr, pBlock, pHolder;
pBlock = hb_errorBlock();
pHolder = hb_itemNew( pBlock );
hb_itemMove( pBlock, pItem );
pBlockPtr = ( PHB_ITEM * ) hb_gcAlloc( sizeof( PHB_ITEM ),
hb_SeqBlockDestructor );
* pBlockPtr = pHolder;
pItem->type = HB_IT_POINTER;
pItem->item.asPointer.value = pBlockPtr;
pItem->item.asPointer.collect = pItem->item.asPointer.single = TRUE;
}
}
| hvm.c | 3481 |
STATIC HB_GARBAGE_FUNC( | hb_withObjectDestructor )
static HB_GARBAGE_FUNC( hb_withObjectDestructor )
{
LONG * plWithObjectBase = ( LONG * ) Cargo;
hb_stackWithObjectSetOffset( * plWithObjectBase );
}
| hvm.c | 3504 |
STATIC VOID | hb_vmWithObjectStart( void )
static void hb_vmWithObjectStart( void )
{
LONG * plWithObjectBase;
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_vmWithObjectStart()"));
pItem = hb_stackAllocItem();
plWithObjectBase = ( LONG * ) hb_gcAlloc( sizeof( LONG ),
hb_withObjectDestructor );
* plWithObjectBase = hb_stackWithObjectOffset();
pItem->type = HB_IT_POINTER;
pItem->item.asPointer.value = plWithObjectBase;
pItem->item.asPointer.collect = pItem->item.asPointer.single = TRUE;
/* The object is pushed directly before this pcode */
/* store position of current WITH OBJECT frame */
hb_stackWithObjectSetOffset( hb_stackTopOffset() - 2 );
}
| hvm.c | 3511 |
VOID | hb_vmEnumRelease( PHB_ITEM pBase, PHB_ITEM pValue )
void hb_vmEnumRelease( PHB_ITEM pBase, PHB_ITEM pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmEnumRelease(%p,%p)", pBase, pValue));
if( pValue )
hb_itemRelease( pValue );
if( HB_IS_OBJECT( pBase ) && hb_vmRequestQuery() == 0 &&
hb_objHasOperator( pBase, HB_OO_OP_ENUMSTOP ) )
{
hb_stackPushReturn();
hb_vmPushNil();
hb_objOperatorCall( HB_OO_OP_ENUMSTOP, hb_stackItemFromTop( -1 ),
pBase, NULL, NULL );
hb_stackPop();
hb_stackPopReturn();
}
}
/*
* extended reference used as enumerator destructor
*/
typedef struct
{
HB_ITEM basevalue;
HB_ITEM oldvalue;
HB_ITEM enumref;
} HB_ENUMREF, * PHB_ENUMREF;
| hvm.c | 3530 |
STATIC PHB_ITEM | hb_vmEnumRefRead( PHB_ITEM pRefer )
static PHB_ITEM hb_vmEnumRefRead( PHB_ITEM pRefer )
{
return &( ( PHB_ENUMREF ) pRefer->item.asExtRef.value )->oldvalue;
}
| hvm.c | 3562 |
STATIC PHB_ITEM | hb_vmEnumRefWrite( PHB_ITEM pRefer, PHB_ITEM pSource )
static PHB_ITEM hb_vmEnumRefWrite( PHB_ITEM pRefer, PHB_ITEM pSource )
{
HB_SYMBOL_UNUSED( pRefer );
HB_SYMBOL_UNUSED( pSource );
return NULL;
}
| hvm.c | 3567 |
STATIC VOID | hb_vmEnumRefCopy( PHB_ITEM pDest )
static void hb_vmEnumRefCopy( PHB_ITEM pDest )
{
pDest->type = HB_IT_NIL;
}
| hvm.c | 3574 |
STATIC VOID | hb_vmEnumRefClear( void * value )
static void hb_vmEnumRefClear( void * value )
{
hb_itemMove( hb_itemUnRefOnce( &( ( PHB_ENUMREF ) value )->enumref ),
&( ( PHB_ENUMREF ) value )->oldvalue );
if( HB_IS_COMPLEX( &( ( PHB_ENUMREF ) value )->basevalue ) )
hb_itemClear( &( ( PHB_ENUMREF ) value )->basevalue );
if( HB_IS_COMPLEX( &( ( PHB_ENUMREF ) value )->enumref ) )
hb_itemClear( &( ( PHB_ENUMREF ) value )->enumref );
hb_xfree( value );
}
| hvm.c | 3579 |
STATIC VOID | hb_vmEnumRefMark( void * value )
static void hb_vmEnumRefMark( void * value )
{
if( HB_IS_GCITEM( &( ( PHB_ENUMREF ) value )->basevalue ) )
hb_gcItemRef( &( ( PHB_ENUMREF ) value )->basevalue );
if( HB_IS_GCITEM( &( ( PHB_ENUMREF ) value )->oldvalue ) )
hb_gcItemRef( &( ( PHB_ENUMREF ) value )->oldvalue );
if( HB_IS_GCITEM( &( ( PHB_ENUMREF ) value )->enumref ) )
hb_gcItemRef( &( ( PHB_ENUMREF ) value )->enumref );
}
| hvm.c | 3591 |
STATIC VOID | hb_vmEnumReference( PHB_ITEM pBase )
static void hb_vmEnumReference( PHB_ITEM pBase )
{
static const HB_EXTREF s_EnumExtRef = {
hb_vmEnumRefRead,
hb_vmEnumRefWrite,
hb_vmEnumRefCopy,
hb_vmEnumRefClear,
hb_vmEnumRefMark };
PHB_ENUMREF pEnumExtRef;
HB_TRACE(HB_TR_DEBUG, ("hb_vmEnumReference(%p)", pBase));
pEnumExtRef = ( PHB_ENUMREF ) hb_xgrab( sizeof( HB_ENUMREF ) );
pEnumExtRef->basevalue.type = HB_IT_NIL;
pEnumExtRef->oldvalue.type = HB_IT_NIL;
pEnumExtRef->enumref.type = HB_IT_NIL;
hb_itemMove( &pEnumExtRef->basevalue, pBase );
pBase->type = HB_IT_BYREF | HB_IT_EXTREF;
pBase->item.asExtRef.value = ( void * ) pEnumExtRef;
pBase->item.asExtRef.func = &s_EnumExtRef;
}
| hvm.c | 3601 |
STATIC VOID | hb_vmEnumStart( BYTE nVars, BYTE nDescend )
/* Test to check the start point of the FOR EACH loop */
static void hb_vmEnumStart( BYTE nVars, BYTE nDescend )
{
BOOL fStart = TRUE;
int i;
/*
pItem = hb_itemUnRef( hb_stackItemFromTop( -( ( int ) nVars << 1 ) ) );
if( ( pItem->type & ( HB_IT_ARRAY | HB_IT_HASH | HB_IT_STRING ) ) == 0 )
{
hb_errRT_BASE( EG_ARG, 1068, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 1, pItem );
return;
}
*/
for( i = ( int ) nVars << 1; i > 0 && fStart; i -= 2 )
{
HB_ITEM_PTR pBase, pValue, pEnumRef, pEnum;
pValue = hb_stackItemFromTop( -i );
/* create extended reference for enumerator destructor */
hb_vmEnumReference( pValue );
pBase = &( ( PHB_ENUMREF ) pValue->item.asExtRef.value )->basevalue;
/* store the reference to control variable */
pEnumRef = hb_stackItemFromTop( -i + 1 );
hb_itemCopy( &( ( PHB_ENUMREF ) pValue->item.asExtRef.value )->enumref,
pEnumRef );
/* the control variable */
pEnum = hb_itemUnRefOnce( pEnumRef );
/* store the old value of control variable and clear it */
hb_itemMove( &( ( PHB_ENUMREF ) pValue->item.asExtRef.value )->oldvalue,
pEnum );
/* set the iterator value */
pEnum->type = HB_IT_BYREF | HB_IT_ENUM;
pEnum->item.asEnum.basePtr = pBase;
pEnum->item.asEnum.valuePtr = NULL;
if( HB_IS_BYREF( pBase ) )
pBase = hb_itemUnRef( pBase );
if( HB_IS_OBJECT( pBase ) && hb_objHasOperator( pBase, HB_OO_OP_ENUMSTART ) )
{
pEnum->item.asEnum.offset = 0;
pEnum->item.asEnum.valuePtr = hb_itemNew( NULL );
hb_vmPushNil();
hb_vmPushLogical( nDescend == 0 );
hb_objOperatorCall( HB_OO_OP_ENUMSTART, hb_stackItemFromTop( -2 ),
pBase, pEnumRef, hb_stackItemFromTop( -1 ) );
hb_stackPop();
if( hb_vmRequestQuery() != 0 || ! hb_vmPopLogical() )
{
fStart = FALSE;
break;
}
else if( hb_objHasOperator( pBase, HB_OO_OP_ENUMSKIP ) )
continue;
hb_itemRelease( pEnum->item.asEnum.valuePtr );
pEnum->item.asEnum.valuePtr = NULL;
}
if( HB_IS_ARRAY( pBase ) )
{
/* the index into an array */
pEnum->item.asEnum.offset = ( nDescend > 0 ) ? 1 :
pBase->item.asArray.value->ulLen;
if( pBase->item.asArray.value->ulLen == 0 )
fStart = FALSE;
}
else if( HB_IS_HASH( pBase ) )
{
ULONG ulLen = hb_hashLen( pBase );
/* the index into a hash */
pEnum->item.asEnum.offset = ( nDescend > 0 ) ? 1 : ulLen;
if( ulLen == 0 )
fStart = FALSE;
}
else if( HB_IS_STRING( pBase ) )
{
/* storage item for single characters */
pEnum->item.asEnum.offset = ( nDescend > 0 ) ? 1 :
pBase->item.asString.length;
if( pBase->item.asString.length )
pEnum->item.asEnum.valuePtr =
hb_itemPutCL( NULL, pBase->item.asString.value +
pEnum->item.asEnum.offset - 1, 1 );
else
fStart = FALSE;
}
else
{
hb_errRT_BASE( EG_ARG, 1068, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 1, pBase );
return;
}
}
hb_vmPushInteger( nVars ); /* number of iterators */
/* empty array/string - do not start enumerations loop */
hb_vmPushLogical( fStart );
}
| hvm.c | 3627 |
STATIC VOID | hb_vmEnumNext( void )
static void hb_vmEnumNext( void )
{
HB_ITEM_PTR pEnumRef, pEnum, pBase;
int i;
for( i = ( int ) hb_stackItemFromTop( -1 )->item.asInteger.value; i > 0; --i )
{
pEnumRef = hb_stackItemFromTop( -( i << 1 ) );
pEnum = hb_itemUnRefOnce( pEnumRef );
pBase = pEnum->item.asEnum.basePtr;
if( HB_IS_BYREF( pBase ) )
pBase = hb_itemUnRef( pBase );
if( HB_IS_ARRAY( pBase ) )
{
if( HB_IS_OBJECT( pBase ) &&
hb_objHasOperator( pBase, HB_OO_OP_ENUMSKIP ) )
{
++pEnum->item.asEnum.offset;
hb_vmPushNil();
hb_vmPushLogical( FALSE );
hb_objOperatorCall( HB_OO_OP_ENUMSKIP, hb_stackItemFromTop( -2 ),
pBase, pEnumRef, hb_stackItemFromTop( -1 ) );
hb_stackPop();
if( hb_vmRequestQuery() != 0 || ! hb_vmPopLogical() )
break;
}
else
{
/* Clear the item value which can be set with RT error
when enumerator was out of array size during unreferencing
*/
if( pEnum->item.asEnum.valuePtr )
{
hb_itemRelease( pEnum->item.asEnum.valuePtr );
pEnum->item.asEnum.valuePtr = NULL;
}
if( ( ULONG ) ++pEnum->item.asEnum.offset >
pBase->item.asArray.value->ulLen )
break;
}
}
else if( HB_IS_HASH( pBase ) )
{
/* Clear the item value which can be set with RT error
when enumerator was out of array size during unreferencing
*/
if( pEnum->item.asEnum.valuePtr )
{
hb_itemRelease( pEnum->item.asEnum.valuePtr );
pEnum->item.asEnum.valuePtr = NULL;
}
if( ( ULONG ) ++pEnum->item.asEnum.offset > hb_hashLen( pBase ) )
break;
}
else if( HB_IS_STRING( pBase ) )
{
if( ( ULONG ) ++pEnum->item.asEnum.offset >
pBase->item.asString.length )
break;
hb_itemPutCL( pEnum->item.asEnum.valuePtr,
pBase->item.asString.value +
pEnum->item.asEnum.offset - 1, 1 );
}
else
{
hb_errRT_BASE( EG_ARG, 1068, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 1, pBase );
return;
}
}
hb_vmPushLogical( i == 0 );
}
| hvm.c | 3732 |
STATIC VOID | hb_vmEnumPrev( void )
static void hb_vmEnumPrev( void )
{
HB_ITEM_PTR pEnumRef, pEnum, pBase;
int i;
for( i = hb_stackItemFromTop( -1 )->item.asInteger.value; i > 0; --i )
{
pEnumRef = hb_stackItemFromTop( -( i << 1 ) );
pEnum = hb_itemUnRefOnce( pEnumRef );
pBase = pEnum->item.asEnum.basePtr;
if( HB_IS_BYREF( pBase ) )
pBase = hb_itemUnRef( pBase );
if( HB_IS_ARRAY( pBase ) )
{
if( HB_IS_OBJECT( pBase ) &&
hb_objHasOperator( pBase, HB_OO_OP_ENUMSKIP ) )
{
--pEnum->item.asEnum.offset;
hb_vmPushNil();
hb_vmPushLogical( TRUE );
hb_objOperatorCall( HB_OO_OP_ENUMSKIP, hb_stackItemFromTop( -2 ),
pBase, pEnumRef, hb_stackItemFromTop( -1 ) );
hb_stackPop();
if( hb_vmRequestQuery() != 0 || ! hb_vmPopLogical() )
break;
}
else
{
/* Clear the item value which can be set with RT error
when enumerator was out of array size during unreferencing
*/
if( pEnum->item.asEnum.valuePtr )
{
hb_itemRelease( pEnum->item.asEnum.valuePtr );
pEnum->item.asEnum.valuePtr = NULL;
}
if( --pEnum->item.asEnum.offset == 0 )
break;
}
}
else if( HB_IS_HASH( pBase ) )
{
/* Clear the item value which can be set with RT error
when enumerator was out of array size during unreferencing
*/
if( pEnum->item.asEnum.valuePtr )
{
hb_itemRelease( pEnum->item.asEnum.valuePtr );
pEnum->item.asEnum.valuePtr = NULL;
}
if( --pEnum->item.asEnum.offset == 0 )
break;
}
else if( HB_IS_STRING( pBase ) )
{
if( --pEnum->item.asEnum.offset == 0 )
break;
hb_itemPutCL( pEnum->item.asEnum.valuePtr,
pBase->item.asString.value +
pEnum->item.asEnum.offset - 1, 1 );
}
else
{
hb_errRT_BASE( EG_ARG, 1068, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 1, pBase );
return;
}
}
hb_vmPushLogical( i == 0 );
}
| hvm.c | 3810 |
STATIC VOID | hb_vmEnumEnd( void )
static void hb_vmEnumEnd( void )
{
int iVars;
/* remove number of iterators */
iVars = hb_stackItemFromTop( -1 )->item.asInteger.value;
hb_stackDec();
while( --iVars >= 0 )
{
hb_stackPop();
hb_stackPop();
}
}
| hvm.c | 3886 |
STATIC LONG | hb_vmSwitch( const BYTE * pCode, LONG offset, USHORT casesCnt )
static LONG hb_vmSwitch( const BYTE * pCode, LONG offset, USHORT casesCnt )
{
HB_ITEM_PTR pSwitch = hb_stackItemFromTop( -1 );
BOOL fFound = FALSE;
if( !( HB_IS_NUMINT( pSwitch ) || HB_IS_STRING( pSwitch ) ) )
{
HB_ITEM_PTR pResult = hb_errRT_BASE_Subst( EG_ARG, 3104, NULL, "SWITCH", 1, pSwitch );
if( !pResult )
return offset;
hb_itemMove( pSwitch, pResult );
hb_itemRelease( pResult );
}
while( !fFound && casesCnt-- )
{
switch( pCode[ offset ] )
{
case HB_P_PUSHLONG:
if( HB_IS_NUMINT( pSwitch ) )
{
fFound = HB_ITEM_GET_NUMINTRAW( pSwitch ) == HB_PCODE_MKLONG( &pCode[ offset + 1 ] );
}
offset += 5;
break;
case HB_P_PUSHSTRSHORT:
if( HB_IS_STRING( pSwitch ) )
{
/*fFound = hb_itemStrCmp( pItem1, pItem2, bExact );*/
fFound = ( ULONG ) pCode[ offset + 1 ] - 1 == pSwitch->item.asString.length &&
memcmp( pSwitch->item.asString.value,
( char * ) &pCode[ offset + 2 ],
pSwitch->item.asString.length ) == 0;
}
offset += 2 + pCode[ offset + 1 ];
break;
case HB_P_PUSHNIL:
/* default clause */
fFound = TRUE;
++offset;
break;
}
switch( pCode[ offset ] )
{
case HB_P_JUMPNEAR:
if( fFound )
offset += ( signed char ) pCode[ offset + 1 ];
else
offset += 2;
break;
case HB_P_JUMP:
if( fFound )
offset += HB_PCODE_MKSHORT( &pCode[ offset + 1 ] );
else
offset += 3;
break;
case HB_P_JUMPFAR:
if( fFound )
offset += HB_PCODE_MKINT24( &pCode[ offset + 1 ] );
else
offset += 4;
break;
}
}
hb_stackPop();
return offset;
}
/* ------------------------------- */
/* Operators (logical) */
| hvm.c | 3907 |
STATIC VOID | hb_vmNot( void )
static void hb_vmNot( void )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_vmNot()"));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_LOGICAL( pItem ) )
{
pItem->type = HB_IT_LOGICAL;
pItem->item.asLogical.value = ! pItem->item.asLogical.value;
}
else if( ! hb_objOperatorCall( HB_OO_OP_NOT, pItem, pItem, NULL, NULL ) )
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1077, NULL, ".NOT.", 1, pItem );
if( pResult )
{
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 3984 |
STATIC VOID | hb_vmAnd( void )
static void hb_vmAnd( void )
{
PHB_ITEM pItem2;
PHB_ITEM pItem1;
HB_TRACE(HB_TR_DEBUG, ("hb_vmAnd()"));
pItem2 = hb_stackItemFromTop( -1 );
pItem1 = hb_stackItemFromTop( -2 );
if( HB_IS_LOGICAL( pItem1 ) && HB_IS_LOGICAL( pItem2 ) )
{
pItem1->type = HB_IT_LOGICAL;
pItem1->item.asLogical.value = pItem1->item.asLogical.value && pItem2->item.asLogical.value;
pItem2->type = HB_IT_NIL;
hb_stackDec();
}
else if( hb_objOperatorCall( HB_OO_OP_AND, pItem1, pItem1, pItem2, NULL ) )
hb_stackPop();
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1078, NULL, ".AND.", 2, pItem1, pItem2 );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem1, pResult );
hb_itemRelease( pResult );
}
}
}
| hvm.c | 4009 |
STATIC VOID | hb_vmOr( void )
static void hb_vmOr( void )
{
PHB_ITEM pItem2;
PHB_ITEM pItem1;
HB_TRACE(HB_TR_DEBUG, ("hb_vmOr()"));
pItem2 = hb_stackItemFromTop( -1 );
pItem1 = hb_stackItemFromTop( -2 );
if( HB_IS_LOGICAL( pItem1 ) && HB_IS_LOGICAL( pItem2 ) )
{
pItem1->type = HB_IT_LOGICAL;
pItem1->item.asLogical.value = pItem1->item.asLogical.value || pItem2->item.asLogical.value;
pItem2->type = HB_IT_NIL;
hb_stackDec();
}
else if( hb_objOperatorCall( HB_OO_OP_OR, pItem1, pItem1, pItem2, NULL ) )
hb_stackPop();
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1079, NULL, ".OR.", 2, pItem1, pItem2 );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem1, pResult );
hb_itemRelease( pResult );
}
}
}
/* ------------------------------- */
/* Array */
| hvm.c | 4042 |
STATIC VOID | hb_vmArrayPush( void )
static void hb_vmArrayPush( void )
{
PHB_ITEM pIndex;
PHB_ITEM pArray;
ULONG ulIndex;
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayPush()"));
pIndex = hb_stackItemFromTop( -1 );
pArray = hb_stackItemFromTop( -2 );
if( HB_IS_HASH( pArray ) && HB_IS_HASHKEY( pIndex ) )
{
PHB_ITEM pValue = hb_hashGetItemPtr( pArray, pIndex, HB_HASH_AUTOADD_ACCESS );
if( pValue )
{
hb_itemCopy( pIndex, pValue );
hb_itemMove( pArray, pIndex );
hb_stackDec();
}
else if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, NULL ) )
hb_stackPop();
else
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 2, pArray, pIndex );
return;
}
else if( HB_IS_INTEGER( pIndex ) )
ulIndex = ( ULONG ) pIndex->item.asInteger.value;
else if( HB_IS_LONG( pIndex ) )
ulIndex = ( ULONG ) pIndex->item.asLong.value;
else if( HB_IS_DOUBLE( pIndex ) )
ulIndex = ( ULONG ) pIndex->item.asDouble.value;
else
{
if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, NULL ) )
hb_stackPop();
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1068, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 2, pArray, pIndex );
if( pResult )
{
hb_stackPop();
hb_itemMove( pArray, pResult );
hb_itemRelease( pResult );
}
}
return;
}
if( HB_IS_ARRAY( pArray ) )
{
if( HB_IS_OBJECT( pArray ) &&
hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, NULL ) )
{
hb_stackPop();
return;
}
if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->ulLen ) )
{
if( hb_gcRefCount( pArray->item.asArray.value ) > 1 )
{
/* this is a temporary copy of an array - we can overwrite
* it with no problem
*/
hb_itemCopy( pArray, pArray->item.asArray.value->pItems + ulIndex - 1 );
hb_stackPop();
}
else
{
/* this is a constant array { 1, 2, 3 } - we cannot use
* the optimization here
*/
hb_itemMove( pIndex, pArray->item.asArray.value->pItems + ulIndex - 1 );
hb_itemMove( pArray, pIndex );
hb_stackDec();
}
}
else if( !HB_IS_OBJECT( pArray ) &&
hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, NULL ) )
hb_stackPop();
else
#ifdef HB_C52_STRICT
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 0 );
#else
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 2, pArray, pIndex );
#endif
}
else if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, NULL ) )
hb_stackPop();
else
hb_errRT_BASE( EG_ARG, 1068, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 2, pArray, pIndex );
}
| hvm.c | 4079 |
STATIC VOID | hb_vmArrayPushRef( void )
static void hb_vmArrayPushRef( void )
{
PHB_ITEM pIndex;
PHB_ITEM pArray;
PHB_ITEM pRefer;
ULONG ulIndex;
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayPushRef()"));
pIndex = hb_stackItemFromTop( -1 );
pRefer = hb_stackItemFromTop( -2 );
pArray = HB_IS_BYREF( pRefer ) ? hb_itemUnRef( pRefer ) : pRefer;
if( HB_IS_HASH( pArray ) && HB_IS_HASHKEY( pIndex ) )
{
PHB_ITEM pValue = hb_hashGetItemRefPtr( pArray, pIndex );
if( pValue )
{
hb_itemCopy( pIndex, pValue );
hb_itemMove( pRefer, pIndex );
hb_stackDec();
}
else if( hb_objHasOperator( pArray, HB_OO_OP_ARRAYINDEX ) )
{
/* create extended object index reference */
hb_vmMsgIndexReference( pRefer, pArray, pIndex );
hb_stackPop();
return;
}
else
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 2, pArray, pIndex );
return;
}
else if( HB_IS_INTEGER( pIndex ) )
ulIndex = ( ULONG ) pIndex->item.asInteger.value;
else if( HB_IS_LONG( pIndex ) )
ulIndex = ( ULONG ) pIndex->item.asLong.value;
else if( HB_IS_DOUBLE( pIndex ) )
ulIndex = ( ULONG ) pIndex->item.asDouble.value;
else if( hb_objHasOperator( pArray, HB_OO_OP_ARRAYINDEX ) )
{
/* create extended object index reference */
hb_vmMsgIndexReference( pRefer, pArray, pIndex );
hb_stackPop();
return;
}
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_ARG, 1068, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 2, pArray, pIndex );
if( pResult )
{
hb_stackPop();
hb_itemMove( pRefer, pResult );
hb_itemRelease( pResult );
}
return;
}
if( HB_IS_ARRAY( pArray ) )
{
if( HB_IS_OBJECT( pArray ) && hb_objHasOperator( pArray, HB_OO_OP_ARRAYINDEX ) )
{
/* create extended object index reference */
hb_vmMsgIndexReference( pRefer, pArray, pIndex );
hb_stackPop();
return;
}
else if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->ulLen ) )
{
/* This function is safe for overwriting passed array, [druzus] */
hb_arrayGetItemRef( pArray, ulIndex, pRefer );
hb_stackDec();
}
else if( !HB_IS_OBJECT( pArray ) && hb_objHasOperator( pArray, HB_OO_OP_ARRAYINDEX ) )
{
/* create extended object index reference */
hb_vmMsgIndexReference( pRefer, pArray, pIndex );
hb_stackPop();
return;
}
else
#ifdef HB_C52_STRICT
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 0 );
#else
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 2, pArray, pIndex );
#endif
}
else if( hb_objHasOperator( pArray, HB_OO_OP_ARRAYINDEX ) )
{
/* create extended object index reference */
hb_vmMsgIndexReference( pRefer, pArray, pIndex );
hb_stackPop();
return;
}
else
hb_errRT_BASE( EG_ARG, 1068, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 2, pArray, pIndex );
}
| hvm.c | 4174 |
STATIC VOID | hb_vmArrayPop( void )
static void hb_vmArrayPop( void )
{
PHB_ITEM pValue;
PHB_ITEM pIndex;
PHB_ITEM pArray;
ULONG ulIndex;
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayPop()"));
pValue = hb_stackItemFromTop( -3 );
pArray = hb_stackItemFromTop( -2 );
pIndex = hb_stackItemFromTop( -1 );
if( HB_IS_BYREF( pArray ) )
pArray = hb_itemUnRef( pArray );
if( HB_IS_HASH( pArray ) && HB_IS_HASHKEY( pIndex ) )
{
PHB_ITEM pDest = hb_hashGetItemPtr( pArray, pIndex, HB_HASH_AUTOADD_ASSIGN );
if( pDest )
{
pValue->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT );
hb_itemMoveFromRef( pDest, pValue );
hb_stackPop();
hb_stackPop();
hb_stackDec(); /* value was moved above hb_stackDec() is enough */
}
else if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, pValue ) )
{
hb_stackPop();
hb_stackPop();
hb_stackPop();
}
else
hb_errRT_BASE( EG_BOUND, 1133, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 3, pArray, pIndex, pValue );
return;
}
else if( HB_IS_INTEGER( pIndex ) )
ulIndex = ( ULONG ) pIndex->item.asInteger.value;
else if( HB_IS_LONG( pIndex ) )
ulIndex = ( ULONG ) pIndex->item.asLong.value;
else if( HB_IS_DOUBLE( pIndex ) )
ulIndex = ( ULONG ) pIndex->item.asDouble.value;
else
{
if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, pValue ) )
{
hb_stackPop();
hb_stackPop();
hb_stackPop();
}
else
hb_errRT_BASE( EG_ARG, 1069, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 1, pIndex );
return;
}
if( HB_IS_ARRAY( pArray ) )
{
if( HB_IS_OBJECT( pArray ) &&
hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, pValue ) )
{
hb_stackPop();
hb_stackPop();
hb_stackPop();
return;
}
if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->ulLen ) )
{
pValue->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT );
hb_itemMoveRef( pArray->item.asArray.value->pItems + ulIndex - 1, pValue );
hb_stackPop();
hb_stackPop();
hb_stackDec(); /* value was moved above hb_stackDec() is enough */
}
else if( !HB_IS_OBJECT( pArray ) &&
hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, pValue ) )
{
hb_stackPop();
hb_stackPop();
hb_stackPop();
}
else
#ifdef HB_C52_STRICT
hb_errRT_BASE( EG_BOUND, 1133, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 0 );
#else
hb_errRT_BASE( EG_BOUND, 1133, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 1, pIndex );
#endif
}
else if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, pValue ) )
{
hb_stackPop();
hb_stackPop();
hb_stackPop();
return;
}
else
hb_errRT_BASE( EG_ARG, 1069, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 1, pIndex );
}
| hvm.c | 4273 |
STATIC VOID | hb_vmArrayGen( ULONG ulElements )
static void hb_vmArrayGen( ULONG ulElements ) /* generates an ulElements Array and fills it from the stack values */
{
PHB_ITEM pArray;
ULONG ulPos;
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayGen(%lu)", ulElements));
/* create new array on HVM stack */
pArray = hb_stackAllocItem();
hb_arrayNew( pArray, ulElements );
if( ulElements )
{
/* move items from HVM stack to created array */
for( ulPos = 0; ulPos < ulElements; ulPos++ )
{
PHB_ITEM pValue = hb_stackItemFromTop( ( int ) ( ulPos - ulElements - 1 ) );
pValue->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT );
hb_itemMove( pArray->item.asArray.value->pItems + ulPos, pValue );
}
/* move the new array to position of first parameter */
hb_itemMove( hb_stackItemFromTop( ( int ) ( -1 - ulElements ) ), pArray );
/* decrease the stack counter - all items are NIL */
hb_stackDecrease( ulElements );
}
}
| hvm.c | 4373 |
STATIC VOID | hb_vmArrayNew( HB_ITEM_PTR pArray, USHORT uiDimension )
static void hb_vmArrayNew( HB_ITEM_PTR pArray, USHORT uiDimension )
{
ULONG ulElements;
HB_ITEM_PTR pDim;
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayNew(%p, %hu)", pArray, uiDimension));
pDim = hb_stackItemFromTop( ( int ) ( -1 - uiDimension ) );
/* use the proper type of number of elements */
if( HB_IS_INTEGER( pDim ) )
ulElements = ( ULONG ) pDim->item.asInteger.value;
else if( HB_IS_LONG( pDim ) )
ulElements = ( ULONG ) pDim->item.asLong.value;
else if( HB_IS_DOUBLE( pDim ) )
ulElements = ( ULONG ) pDim->item.asDouble.value;
else
/* NOTE: Clipper creates empty array if non-numeric value is
* specified as dimension and stops further processing.
* There is no runtime error generated.
*/
ulElements = 0;
/* create an array */
hb_arrayNew( pArray, ulElements );
if( --uiDimension )
{
/* call self recursively to create next dimensions
*/
while( ulElements-- )
hb_vmArrayNew( pArray->item.asArray.value->pItems + ulElements, uiDimension );
}
}
| hvm.c | 4401 |
STATIC VOID | hb_vmArrayDim( USHORT uiDimensions )
static void hb_vmArrayDim( USHORT uiDimensions ) /* generates an uiDimensions Array and initialize those dimensions from the stack values */
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayDim(%hu)", uiDimensions));
hb_vmArrayNew( hb_stackAllocItem(), uiDimensions );
hb_itemMove( hb_stackItemFromTop( ( int ) ( -1 - uiDimensions ) ),
hb_stackItemFromTop( -1 ) );
do
{
hb_stackPop();
}
while( --uiDimensions );
}
| hvm.c | 4439 |
STATIC VOID | hb_vmHashGen( ULONG ulElements )
static void hb_vmHashGen( ULONG ulElements ) /* generates an ulElements Hash and fills it from the stack values */
{
PHB_ITEM pHash, pKey, pVal;
HB_TRACE(HB_TR_DEBUG, ("hb_vmHashGen(%lu)", ulElements));
/* create new hash item */
pHash = hb_hashNew( NULL );
hb_hashPreallocate( pHash, ulElements );
while( ulElements-- )
{
pKey = hb_stackItemFromTop( -2 );
pVal = hb_stackItemFromTop( -1 );
if( HB_IS_HASHKEY( pKey ) )
{
hb_hashAdd( pHash, pKey, pVal );
hb_stackPop();
hb_stackPop();
}
else
{
hb_errRT_BASE( EG_BOUND, 1133, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 3, pHash, pKey, pVal );
break;
}
}
hb_itemMove( hb_stackAllocItem(), pHash );
hb_itemRelease( pHash );
}
/* ------------------------------- */
/* Macros */
| hvm.c | 4454 |
STATIC VOID | hb_vmMacroPushIndex( void )
static void hb_vmMacroPushIndex( void )
{
ULONG ulIndexes;
HB_TRACE(HB_TR_DEBUG, ("hb_vmMacroPushIndex()"));
/*
* Now the top most element on the stack points to number of
* additional indexes to generated array
*/
ulIndexes = hb_itemGetNL( hb_stackItemFromTop( -1 ) );
hb_stackDec();
if( ulIndexes > 1 )
{
PHB_ITEM pIndexArray;
ULONG ul = 1;
hb_vmArrayGen( ulIndexes - 1 );
pIndexArray = hb_itemNew( hb_stackItemFromTop( -1 ) );
hb_stackPop();
/* First index is still on stack.*/
do
{
hb_vmArrayPush();
/* RT error? */
if( hb_stackGetActionRequest() != 0 )
break;
hb_vmPush( hb_arrayGetItemPtr( pIndexArray, ul ) );
}
while( ++ul < ulIndexes );
hb_itemRelease( pIndexArray );
}
else if( ulIndexes == 0 )
hb_vmPushNil(); /* It will force RT error later in array push or pop */
}
| hvm.c | 4488 |
STATIC LONG | hb_vmArgsJoin( LONG lLevel, USHORT uiArgSets )
static LONG hb_vmArgsJoin( LONG lLevel, USHORT uiArgSets )
{
LONG lArgs, lRestArgs, lOffset;
PHB_ITEM pArgs = hb_stackItemFromTop( lLevel ) ;
lArgs = hb_itemGetNL( pArgs );
if( HB_IS_COMPLEX( pArgs ) )
hb_itemClear( pArgs );
if( --uiArgSets )
{
lRestArgs = lArgs;
lArgs += hb_vmArgsJoin( lLevel - lArgs - 1, uiArgSets );
lOffset = lLevel - lRestArgs - uiArgSets;
while( lRestArgs-- )
{
hb_itemMove( hb_stackItemFromTop( lOffset ),
hb_stackItemFromTop( lOffset + uiArgSets ) );
++lOffset;
}
}
return lArgs;
}
| hvm.c | 4527 |
STATIC VOID | hb_vmMacroDo( USHORT uiArgSets )
static void hb_vmMacroDo( USHORT uiArgSets )
{
LONG lArgs;
HB_TRACE(HB_TR_DEBUG, ("hb_vmMacroDo(%hu)", uiArgSets));
lArgs = hb_vmArgsJoin( -1, uiArgSets );
hb_stackDecrease( uiArgSets );
hb_vmDo( ( USHORT ) lArgs );
}
| hvm.c | 4567 |
STATIC VOID | hb_vmMacroFunc( USHORT uiArgSets )
static void hb_vmMacroFunc( USHORT uiArgSets )
{
LONG lArgs;
HB_TRACE(HB_TR_DEBUG, ("hb_vmMacroFunc(%hu)", uiArgSets));
lArgs = hb_vmArgsJoin( -1, uiArgSets );
hb_stackDecrease( uiArgSets );
hb_vmDo( ( USHORT ) lArgs );
hb_stackPushReturn();
}
| hvm.c | 4578 |
STATIC VOID | hb_vmMacroSend( USHORT uiArgSets )
static void hb_vmMacroSend( USHORT uiArgSets )
{
LONG lArgs;
HB_TRACE(HB_TR_DEBUG, ("hb_vmMacroSend(%hu)", uiArgSets));
lArgs = hb_vmArgsJoin( -1, uiArgSets );
hb_stackDecrease( uiArgSets );
hb_vmSend( ( USHORT ) lArgs );
hb_stackPushReturn();
}
| hvm.c | 4590 |
STATIC VOID | hb_vmMacroArrayGen( USHORT uiArgSets )
static void hb_vmMacroArrayGen( USHORT uiArgSets )
{
LONG lArgs;
HB_TRACE(HB_TR_DEBUG, ("hb_vmMacroArrayGen(%hu)", uiArgSets));
lArgs = hb_vmArgsJoin( -1, uiArgSets );
hb_stackDecrease( uiArgSets );
hb_vmArrayGen( lArgs );
}
| hvm.c | 4602 |
STATIC VOID | hb_vmPushVParams( void )
static void hb_vmPushVParams( void )
{
int iPCount, iFirst, i = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushVParams()"));
iFirst = hb_stackBaseItem()->item.asSymbol.paramdeclcnt;
iPCount = hb_pcount();
while( ++iFirst <= iPCount )
{
hb_vmPush( hb_stackItemFromBase( iFirst ) );
i++;
}
hb_vmPushInteger( i );
}
/* ------------------------------- */
/* Database */
| hvm.c | 4613 |
STATIC ERRCODE | hb_vmSelectWorkarea( PHB_ITEM pAlias, PHB_SYMB pField )
static ERRCODE hb_vmSelectWorkarea( PHB_ITEM pAlias, PHB_SYMB pField )
{
ERRCODE errCode;
BOOL fRepeat;
HB_TRACE(HB_TR_DEBUG, ("hb_vmSelectWorkArea(%p,%p)", pAlias, pField));
/* NOTE: Clipper doesn't generate an error if an workarea specified
* as numeric value cannot be selected
*/
do
{
fRepeat = FALSE;
errCode = SUCCESS;
switch( HB_ITEM_TYPE( pAlias ) )
{
case HB_IT_INTEGER:
/* Alias was used as integer value, for example: 4->field
* or it was saved on the stack using hb_vmPushAlias()
* or was evaluated from an expression, (nWorkArea)->field
*/
hb_rddSelectWorkAreaNumber( pAlias->item.asInteger.value );
pAlias->type = HB_IT_NIL;
break;
case HB_IT_LONG:
/* Alias was evaluated from an expression, (nWorkArea)->field
*/
hb_rddSelectWorkAreaNumber( ( int ) pAlias->item.asLong.value );
pAlias->type = HB_IT_NIL;
break;
case HB_IT_DOUBLE:
/* Alias was evaluated from an expression, (nWorkArea)->field
*/
hb_rddSelectWorkAreaNumber( ( int ) pAlias->item.asDouble.value );
pAlias->type = HB_IT_NIL;
break;
case HB_IT_SYMBOL:
/* Alias was specified using alias identifier, for example: al->field
*/
errCode = hb_rddSelectWorkAreaSymbol( pAlias->item.asSymbol.value );
pAlias->type = HB_IT_NIL;
break;
case HB_IT_STRING:
{
/* Alias was evaluated from an expression, for example: (cVar)->field
*/
/* expand '&' operator if exists */
char * szAlias;
BOOL bNewString;
szAlias = hb_macroExpandString( pAlias->item.asString.value, pAlias->item.asString.length, &bNewString );
if( pField )
{
errCode = hb_rddSelectWorkAreaAlias( szAlias );
}
else
{
int iArea;
hb_rddGetAliasNumber( szAlias, &iArea );
hb_rddSelectWorkAreaNumber( iArea );
}
if( bNewString )
hb_xfree( szAlias );
hb_itemClear( pAlias );
break;
}
default:
if( pField )
{
PHB_ITEM pSubstVal;
hb_vmPushString( pField->szName, strlen( pField->szName ) );
pSubstVal = hb_errRT_BASE_Subst( EG_ARG, 1065, NULL, "&",
2, pAlias, hb_stackItemFromTop( -1 ) );
hb_stackPop();
if( pSubstVal )
{
hb_itemMove( pAlias, pSubstVal );
hb_itemRelease( pSubstVal );
fRepeat = TRUE;
}
else
{
hb_itemSetNil( pAlias );
errCode = FAILURE;
}
}
else
{
hb_rddSelectWorkAreaNumber( -1 );
hb_itemSetNil( pAlias );
}
break;
}
}
while( fRepeat );
return errCode;
}
| hvm.c | 4633 |
STATIC VOID | hb_vmSwapAlias( void )
static void hb_vmSwapAlias( void )
{
HB_ITEM_PTR pItem;
HB_ITEM_PTR pWorkArea;
HB_TRACE(HB_TR_DEBUG, ("hb_vmSwapAlias()"));
pItem = hb_stackItemFromTop( -1 );
pWorkArea = hb_stackItemFromTop( -2 );
hb_vmSelectWorkarea( pWorkArea, NULL );
hb_itemMove( pWorkArea, pItem );
hb_stackDec();
}
/* ------------------------------- */
/* Execution */
| hvm.c | 4740 |
HB_EXPORT VOID | hb_vmDo( USHORT uiParams )
HB_EXPORT void hb_vmDo( USHORT uiParams )
{
HB_STACK_STATE sStackState;
PHB_SYMB pSym;
PHB_ITEM pSelf;
#ifndef HB_NO_DEBUG
BOOL bDebugPrevState;
#endif
#ifndef HB_NO_PROFILER
ULONG ulClock = 0;
BOOL bProfiler = hb_bProfiler; /* because profiler state may change */
#endif
HB_TRACE(HB_TR_DEBUG, ("hb_vmDo(%hu)", uiParams));
#ifndef HB_NO_PROFILER
if( bProfiler )
ulClock = ( ULONG ) clock();
#endif
/* Poll the console keyboard
#ifndef HB_GUI
hb_inkeyPoll();
#endif
*/
pSym = hb_stackNewFrame( &sStackState, uiParams )->item.asSymbol.value;
pSelf = hb_stackSelfItem(); /* NIL, OBJECT or BLOCK */
#ifndef HB_NO_DEBUG
bDebugPrevState = s_bDebugging;
s_bDebugging = FALSE;
#endif
if( ! HB_IS_NIL( pSelf ) ) /* are we sending a message ? */
{
PHB_SYMB pExecSym;
pExecSym = hb_objGetMethod( pSelf, pSym, &sStackState );
if( pExecSym && ( pExecSym->scope.value & HB_FS_DEFERRED ) && pExecSym->pDynSym )
pExecSym = pExecSym->pDynSym->pSymbol;
if( pExecSym && pExecSym->value.pFunPtr )
{
HB_TRACE_PRG(("Calling: %s:%s", hb_objGetClsName( pSelf ), pSym->szName));
if( pExecSym->scope.value & HB_FS_PCODEFUNC )
/* Running pCode dynamic function from .HRB */
hb_vmExecute( pExecSym->value.pCodeFunc->pCode,
pExecSym->value.pCodeFunc->pSymbols );
else
pExecSym->value.pFunPtr();
#ifndef HB_NO_PROFILER
if( bProfiler )
hb_mthAddTime( clock() - ulClock );
#endif
}
else if( pSym->szName[ 0 ] == '_' )
hb_errRT_BASE_SubstR( EG_NOVARMETHOD, 1005, NULL, pSym->szName + 1, HB_ERR_ARGS_SELFPARAMS );
else
hb_errRT_BASE_SubstR( EG_NOMETHOD, 1004, NULL, pSym->szName, HB_ERR_ARGS_SELFPARAMS );
}
else /* it is a function */
{
if( ( pSym->scope.value & HB_FS_DEFERRED ) && pSym->pDynSym )
pSym = pSym->pDynSym->pSymbol;
if( pSym->value.pFunPtr )
{
HB_TRACE_PRG(("Calling: %s", pSym->szName));
#ifndef HB_NO_PROFILER
if( bProfiler && pSym->pDynSym )
pSym->pDynSym->ulRecurse++;
#endif
/* Running pCode dynamic function from .HRB? */
if( pSym->scope.value & HB_FS_PCODEFUNC )
hb_vmExecute( pSym->value.pCodeFunc->pCode,
pSym->value.pCodeFunc->pSymbols );
else
pSym->value.pFunPtr();
#ifndef HB_NO_PROFILER
if( bProfiler && pSym->pDynSym )
{
pSym->pDynSym->ulCalls++; /* profiler support */
/* Time spent has to be added only inside topmost call of a recursive function */
if( --pSym->pDynSym->ulRecurse == 0 )
pSym->pDynSym->ulTime += clock() - ulClock; /* profiler support */
}
#endif
}
else
hb_errRT_BASE_SubstR( EG_NOFUNC, 1001, NULL, pSym->szName, HB_ERR_ARGS_BASEPARAMS );
}
#ifndef HB_NO_DEBUG
if( s_bDebugging )
hb_vmDebuggerEndProc();
s_bDebugging = bDebugPrevState;
#endif
hb_stackOldFrame( &sStackState );
}
| hvm.c | 4763 |
HB_EXPORT VOID | hb_vmSend( USHORT uiParams )
HB_EXPORT void hb_vmSend( USHORT uiParams )
{
HB_STACK_STATE sStackState;
PHB_SYMB pSym;
PHB_SYMB pExecSym;
PHB_ITEM pSelf;
#ifndef HB_NO_DEBUG
BOOL bDebugPrevState;
#endif
#ifndef HB_NO_PROFILER
ULONG ulClock = 0;
BOOL bProfiler = hb_bProfiler; /* because profiler state may change */
#endif
HB_TRACE(HB_TR_DEBUG, ("hb_vmSend(%hu)", uiParams));
#ifndef HB_NO_PROFILER
if( bProfiler )
ulClock = ( ULONG ) clock();
#endif
/* Poll the console keyboard
#ifndef HB_GUI
hb_inkeyPoll();
#endif
*/
pSym = hb_stackNewFrame( &sStackState, uiParams )->item.asSymbol.value;
pSelf = hb_stackSelfItem(); /* NIL, OBJECT or BLOCK */
#ifndef HB_NO_DEBUG
bDebugPrevState = s_bDebugging;
s_bDebugging = FALSE;
#endif
pExecSym = hb_objGetMethod( pSelf, pSym, &sStackState );
if( pExecSym && ( pExecSym->scope.value & HB_FS_DEFERRED ) && pExecSym->pDynSym )
pExecSym = pExecSym->pDynSym->pSymbol;
if( pExecSym && pExecSym->value.pFunPtr )
{
HB_TRACE_PRG(("Calling: %s:%s", hb_objGetClsName( pSelf ), pSym->szName));
if( pExecSym->scope.value & HB_FS_PCODEFUNC )
/* Running pCode dynamic function from .HRB */
hb_vmExecute( pExecSym->value.pCodeFunc->pCode,
pExecSym->value.pCodeFunc->pSymbols );
else
pExecSym->value.pFunPtr();
#ifndef HB_NO_PROFILER
if( bProfiler )
hb_mthAddTime( clock() - ulClock );
#endif
}
else if( pSym->szName[ 0 ] == '_' )
hb_errRT_BASE_SubstR( EG_NOVARMETHOD, 1005, NULL, pSym->szName + 1, HB_ERR_ARGS_SELFPARAMS );
else
hb_errRT_BASE_SubstR( EG_NOMETHOD, 1004, NULL, pSym->szName, HB_ERR_ARGS_SELFPARAMS );
#ifndef HB_NO_DEBUG
if( s_bDebugging )
hb_vmDebuggerEndProc();
s_bDebugging = bDebugPrevState;
#endif
hb_stackOldFrame( &sStackState );
}
| hvm.c | 4864 |
STATIC VOID | hb_vmPushObjectVarRef( void )
static void hb_vmPushObjectVarRef( void )
{
HB_STACK_STATE sStackState;
PHB_ITEM pItem;
PHB_SYMB pSym;
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushObjectVarRef()"));
pItem = hb_stackNewFrame( &sStackState, 0 ); /* procedure name */
pSym = pItem->item.asSymbol.value;
if( !hb_objGetVarRef( hb_stackSelfItem(), pSym, &sStackState ) &&
hb_vmRequestQuery() == 0 )
hb_errRT_BASE_SubstR( EG_NOVARMETHOD, 1005, NULL, pSym->szName + ( pSym->szName[ 0 ] == '_' ? 1 : 0 ), 1, hb_stackSelfItem() );
hb_stackOldFrame( &sStackState );
hb_stackPushReturn();
}
| hvm.c | 4931 |
STATIC HARBOUR | hb_vmDoBlock( void )
static HARBOUR hb_vmDoBlock( void )
{
PHB_ITEM pBlock;
int iParam;
HB_TRACE(HB_TR_DEBUG, ("hb_vmDoBlock()"));
pBlock = hb_stackSelfItem();
if( ! HB_IS_BLOCK( pBlock ) )
hb_errInternal( HB_EI_VMNOTCBLOCK, NULL, "hb_vmDoBlock()", NULL );
/* Check for valid count of parameters */
iParam = pBlock->item.asBlock.paramcnt - hb_pcount();
hb_stackBaseItem()->item.asSymbol.paramdeclcnt =
pBlock->item.asBlock.paramcnt;
/* add missing parameters */
while( --iParam >= 0 )
hb_vmPushNil();
/* set the current line number to a line where the codeblock was defined
*/
hb_stackBaseItem()->item.asSymbol.stackstate->uiLineNo = pBlock->item.asBlock.lineno;
hb_stackBaseItem()->item.asSymbol.stackstate->uiClass = pBlock->item.asBlock.hclass;
hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod = pBlock->item.asBlock.method;
hb_codeblockEvaluate( pBlock );
}
| hvm.c | 4951 |
HB_ITEM_PTR | hb_vmEvalBlock( HB_ITEM_PTR pBlock )
HB_ITEM_PTR hb_vmEvalBlock( HB_ITEM_PTR pBlock )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmEvalBlock(%p)", pBlock));
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pBlock );
hb_vmSend( 0 );
return hb_stackReturnItem();
}
| hvm.c | 4981 |
HB_ITEM_PTR | hb_vmEvalBlockV( HB_ITEM_PTR pBlock, ULONG ulArgCount, ... )
HB_ITEM_PTR hb_vmEvalBlockV( HB_ITEM_PTR pBlock, ULONG ulArgCount, ... )
{
va_list va;
ULONG i;
HB_TRACE(HB_TR_DEBUG, ("hb_vmEvalBlockV(%p, %hu, ...)", pBlock, ulArgCount));
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pBlock );
va_start( va, ulArgCount );
for( i = 1; i <= ulArgCount; i++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
/* take care here, possible loss of data long to short ... */
/* added an explicit casting here for VC++ JFL */
hb_vmSend( ( USHORT ) ulArgCount );
return hb_stackReturnItem();
}
| hvm.c | 4993 |
HB_EXPORT PHB_ITEM | hb_vmEvalBlockOrMacro( PHB_ITEM pItem )
HB_EXPORT PHB_ITEM hb_vmEvalBlockOrMacro( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmEvalBlockOrMacro(%p)", pItem));
if( HB_IS_BLOCK( pItem ) )
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pItem );
hb_vmSend( 0 );
}
else
{
HB_MACRO_PTR pMacro = ( HB_MACRO_PTR ) hb_itemGetPtr( pItem );
if( pMacro )
{
hb_macroRun( pMacro );
hb_stackPopReturn();
}
else
{
hb_itemSetNil( hb_stackReturnItem() );
}
}
return hb_stackReturnItem();
}
| hvm.c | 5023 |
HB_EXPORT VOID | hb_vmDestroyBlockOrMacro( PHB_ITEM pItem )
HB_EXPORT void hb_vmDestroyBlockOrMacro( PHB_ITEM pItem )
{
if( HB_IS_POINTER( pItem ) )
{
HB_MACRO_PTR pMacro = ( HB_MACRO_PTR ) hb_itemGetPtr( pItem );
if( pMacro )
{
hb_macroDelete( pMacro );
}
}
hb_itemRelease( pItem );
}
| hvm.c | 5051 |
VOID | hb_vmFunction( USHORT uiParams )
void hb_vmFunction( USHORT uiParams )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmFunction(%hu)", uiParams));
hb_itemSetNil( hb_stackReturnItem() );
hb_vmDo( uiParams );
}
| hvm.c | 5069 |
STATIC VOID | hb_vmDebugEntry( int nMode, int nLine, char *szName, int nIndex, int nFrame )
static void hb_vmDebugEntry( int nMode, int nLine, char *szName, int nIndex, int nFrame )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmDebugEntry"));
HB_SYMBOL_UNUSED( nFrame );
switch( nMode )
{
case HB_DBG_MODULENAME:
hb_vmPushDynSym( s_pDynsDbgEntry );
hb_vmPushNil();
hb_vmPushInteger( HB_DBG_MODULENAME );
hb_vmPushString( szName, strlen( szName ) );
hb_vmDo( 2 );
break;
case HB_DBG_LOCALNAME:
hb_vmPushDynSym( s_pDynsDbgEntry );
hb_vmPushNil();
hb_vmPushInteger( HB_DBG_LOCALNAME );
hb_vmPushInteger( nIndex );
hb_vmPushString( szName, strlen( szName ) );
hb_vmDo( 3 );
break;
case HB_DBG_STATICNAME:
hb_vmPushDynSym( s_pDynsDbgEntry );
hb_vmPushNil();
hb_vmPushInteger( HB_DBG_STATICNAME );
hb_vmPushLong( hb_stackGetStaticsBase() ); /* current static frame */
hb_vmPushInteger( nIndex ); /* variable index */
hb_vmPushString( szName, strlen( szName ) );
hb_vmDo( 4 );
break;
case HB_DBG_ENDPROC:
hb_stackPushReturn(); /* saves the previous returned value */
hb_vmPushDynSym( s_pDynsDbgEntry );
hb_vmPushNil();
hb_vmPushInteger( HB_DBG_ENDPROC );
hb_vmDo( 1 );
hb_stackPopReturn(); /* restores the previous returned value */
break;
case HB_DBG_SHOWLINE:
hb_vmPushDynSym( s_pDynsDbgEntry );
hb_vmPushNil();
hb_vmPushInteger( HB_DBG_SHOWLINE );
hb_vmPushInteger( nLine );
hb_vmDo( 2 );
break;
case HB_DBG_GETENTRY:
/* Try to get C dbgEntry() function pointer */
hb_vmPushDynSym( s_pDynsDbgEntry );
hb_vmPushNil();
hb_vmPushInteger( HB_DBG_GETENTRY );
hb_vmDo( 1 );
break;
case HB_DBG_VMQUIT:
hb_vmPushDynSym( s_pDynsDbgEntry );
hb_vmPushNil();
hb_vmPushInteger( HB_DBG_VMQUIT );
hb_vmDo( 1 );
break;
}
}
| hvm.c | 5078 |
STATIC VOID | hb_vmDummyDebugEntry( int nMode, int nLine, char *szName, int nIndex, int nFrame )
static void hb_vmDummyDebugEntry( int nMode, int nLine, char *szName, int nIndex, int nFrame )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmDummyDebugEntry"));
HB_SYMBOL_UNUSED( nMode );
HB_SYMBOL_UNUSED( nLine );
HB_SYMBOL_UNUSED( szName );
HB_SYMBOL_UNUSED( nIndex );
HB_SYMBOL_UNUSED( nFrame );
}
| hvm.c | 5147 |
STATIC VOID | hb_vmDebuggerExit( void )
static void hb_vmDebuggerExit( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmDebuggerExit"));
/* is debugger linked ? */
if( s_pFunDbgEntry )
{
s_bDebugging = FALSE;
/* inform debugger that we are quitting now */
s_pFunDbgEntry( HB_DBG_VMQUIT, 0, NULL, 0, 0 );
/* set dummy debugger function to avoid debugger activation in .prg
* destructors if any */
s_pFunDbgEntry = hb_vmDummyDebugEntry;
}
}
| hvm.c | 5158 |
STATIC VOID | hb_vmLocalName( USHORT uiLocal, char * szLocalName )
static void hb_vmLocalName( USHORT uiLocal, char * szLocalName ) /* locals and parameters index and name information for the debugger */
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmLocalName(%hu, %s)", uiLocal, szLocalName));
if( s_bDebugging )
{
s_bDebugging = FALSE;
s_pFunDbgEntry( HB_DBG_LOCALNAME, 0, szLocalName, uiLocal, 0 );
s_bDebugging = TRUE;
}
}
| hvm.c | 5174 |
STATIC VOID | hb_vmStaticName( BYTE bIsGlobal, USHORT uiStatic, char * szStaticName )
static void hb_vmStaticName( BYTE bIsGlobal, USHORT uiStatic, char * szStaticName ) /* statics vars information for the debugger */
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmStaticName(%hu, %s)", uiStatic, szStaticName));
HB_SYMBOL_UNUSED( bIsGlobal );
if( s_bDebugging )
{
s_bDebugging = FALSE;
s_pFunDbgEntry( HB_DBG_STATICNAME, 0, szStaticName, uiStatic, hb_stackGetStaticsBase() );
s_bDebugging = TRUE;
}
}
| hvm.c | 5186 |
STATIC VOID | hb_vmModuleName( char * szModuleName )
static void hb_vmModuleName( char * szModuleName ) /* PRG and function name information for the debugger */
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmModuleName(%s)", szModuleName));
#ifdef HB_NO_DEBUG
HB_SYMBOL_UNUSED( szModuleName );
#else
if( s_pFunDbgEntry )
{
s_bDebugging = FALSE;
s_pFunDbgEntry( HB_DBG_MODULENAME, 0, szModuleName, 0, 0 );
s_bDebugging = TRUE;
}
#endif
}
| hvm.c | 5200 |
STATIC VOID | hb_vmDebuggerEndProc( void )
static void hb_vmDebuggerEndProc( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmDebuggerEndProc()"));
s_bDebugging = FALSE;
s_pFunDbgEntry( HB_DBG_ENDPROC, 0, NULL, 0, 0 );
}
| hvm.c | 5217 |
STATIC VOID | hb_vmDebuggerShowLine( USHORT uiLine )
static void hb_vmDebuggerShowLine( USHORT uiLine ) /* makes the debugger shows a specific source code line */
{
BOOL bDebugging = s_bDebugging;
HB_TRACE(HB_TR_DEBUG, ("hb_vmDebuggerShowLine(%hu)", uiLine));
s_bDebugging = FALSE;
s_pFunDbgEntry( HB_DBG_SHOWLINE, uiLine, NULL, 0, 0 );
s_bDebugging = bDebugging;
}
| hvm.c | 5225 |
STATIC VOID | hb_vmFrame( USHORT usLocals, BYTE bParams )
static void hb_vmFrame( USHORT usLocals, BYTE bParams )
{
PHB_ITEM pBase;
int iTotal;
HB_TRACE(HB_TR_DEBUG, ("hb_vmFrame(%d, %d)", (int) usLocals, (int) bParams));
pBase = hb_stackBaseItem();
#if 0
/* This old code which clears additional parameters to make space for
* local variables without updating pBase->item.asSymbol.paramdeclcnt
*/
iTotal = pBase->item.asSymbol.paramcnt - bParams;
if( iTotal > 0 )
{
pBase->item.asSymbol.paramcnt = bParams;
do
hb_itemClear( hb_stackItemFromTop( -iTotal ) );
while( --iTotal > 0 );
}
iTotal = usLocals + bParams;
if( iTotal )
{
iTotal -= pBase->item.asSymbol.paramcnt;
while( --iTotal >= 0 )
hb_vmPushNil();
}
#else
pBase->item.asSymbol.paramdeclcnt = bParams;
iTotal = bParams - pBase->item.asSymbol.paramcnt;
if( iTotal < 0 )
iTotal = 0;
iTotal += usLocals;
if( iTotal )
{
do
hb_vmPushNil();
while( --iTotal > 0 );
}
#endif
}
| hvm.c | 5237 |
STATIC VOID | hb_vmVFrame( USHORT usLocals, BYTE bParams )
static void hb_vmVFrame( USHORT usLocals, BYTE bParams )
{
PHB_ITEM pBase;
int iTotal;
HB_TRACE(HB_TR_DEBUG, ("hb_vmVFrame(%d, %d)", (int) usLocals, (int) bParams));
pBase = hb_stackBaseItem();
pBase->item.asSymbol.paramdeclcnt = bParams;
iTotal = bParams - pBase->item.asSymbol.paramcnt;
if( iTotal < 0 )
iTotal = 0;
iTotal += usLocals;
if( iTotal )
{
do
hb_vmPushNil();
while( --iTotal > 0 );
}
}
| hvm.c | 5283 |
STATIC VOID | hb_vmSFrame( PHB_SYMB pSym )
static void hb_vmSFrame( PHB_SYMB pSym ) /* sets the statics frame for a function */
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmSFrame(%p)", pSym));
/* _INITSTATICS is now the statics frame. Statics() changed it! */
hb_stackSetStaticsBase( pSym->value.lStaticsBase );
}
| hvm.c | 5307 |
STATIC VOID | hb_vmStatics( PHB_SYMB pSym, USHORT uiStatics )
static void hb_vmStatics( PHB_SYMB pSym, USHORT uiStatics ) /* initializes the global aStatics array or redimensionates it */
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmStatics(%p, %hu)", pSym, uiStatics));
if( HB_IS_NIL( &s_aStatics ) )
{
pSym->value.lStaticsBase = 0; /* statics frame for this PRG */
hb_arrayNew( &s_aStatics, uiStatics );
}
else
{
pSym->value.lStaticsBase = hb_arrayLen( &s_aStatics );
hb_arraySize( &s_aStatics, ( ULONG ) pSym->value.lStaticsBase + uiStatics );
}
}
| hvm.c | 5315 |
STATIC VOID | hb_vmEndBlock( void )
static void hb_vmEndBlock( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmEndBlock()"));
hb_stackPopReturn();
}
| hvm.c | 5331 |
STATIC VOID | hb_vmRetValue( void )
static void hb_vmRetValue( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmRetValue()"));
hb_stackPopReturn();
hb_stackReturnItem()->type &= ~HB_IT_MEMOFLAG;
}
/* ------------------------------- */
/* Push */
| hvm.c | 5338 |
HB_EXPORT VOID | hb_vmPush( PHB_ITEM pItem )
HB_EXPORT void hb_vmPush( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmPush(%p)", pItem));
hb_itemCopy( hb_stackAllocItem(), pItem );
}
| hvm.c | 5350 |
HB_EXPORT VOID | hb_vmPushState( void )
HB_EXPORT void hb_vmPushState( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushState()"));
hb_stackPushReturn();
}
| hvm.c | 5357 |
HB_EXPORT VOID | hb_vmPushNil( void )
HB_EXPORT void hb_vmPushNil( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushNil()"));
hb_stackAllocItem()->type = HB_IT_NIL;
}
| hvm.c | 5364 |
HB_EXPORT VOID | hb_vmPushLogical( BOOL bValue )
HB_EXPORT void hb_vmPushLogical( BOOL bValue )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushLogical(%d)", (int) bValue));
pItem->type = HB_IT_LOGICAL;
pItem->item.asLogical.value = bValue;
}
| hvm.c | 5371 |
HB_EXPORT VOID | hb_vmPushNumber( double dNumber, int iDec )
HB_EXPORT void hb_vmPushNumber( double dNumber, int iDec )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushNumber(%lf, %d)", dNumber, iDec));
if( iDec )
hb_vmPushDouble( dNumber, iDec );
else if( HB_DBL_LIM_INT( dNumber ) )
hb_vmPushInteger( ( int ) dNumber );
else if( HB_DBL_LIM_LONG( dNumber ) )
hb_vmPushHBLong( ( HB_LONG ) dNumber );
else
hb_vmPushDouble( dNumber, hb_set.HB_SET_DECIMALS );
}
| hvm.c | 5381 |
STATIC INT | hb_vmCalcIntWidth( HB_LONG lNumber )
static int hb_vmCalcIntWidth( HB_LONG lNumber )
{
int iWidth;
if( lNumber <= -1000000000L )
{
iWidth = 20;
}
else
{
iWidth = 10;
while( lNumber >= 1000000000L )
{
iWidth++;
lNumber /= 10;
}
}
return iWidth;
}
| hvm.c | 5399 |
HB_EXPORT VOID | hb_vmPushInteger( int iNumber )
HB_EXPORT void hb_vmPushInteger( int iNumber )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushInteger(%d)", iNumber));
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = iNumber;
pItem->item.asInteger.length = HB_INT_LENGTH( iNumber );
}
| hvm.c | 5419 |
STATIC VOID | hb_vmPushIntegerConst( int iNumber )
static void hb_vmPushIntegerConst( int iNumber )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushIntegerConst(%d)", iNumber));
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = iNumber;
pItem->item.asInteger.length = hb_vmCalcIntWidth( iNumber );
}
| hvm.c | 5431 |
STATIC VOID | hb_vmPushLongConst( long lNumber )
static void hb_vmPushLongConst( long lNumber )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushLongConst(%ld)", lNumber));
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = ( HB_LONG ) lNumber;
pItem->item.asLong.length = hb_vmCalcIntWidth( lNumber );
}
| hvm.c | 5442 |
HB_EXPORT VOID | hb_vmPushLong( long lNumber )
HB_EXPORT void hb_vmPushLong( long lNumber )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushLong(%ld)", lNumber));
#if HB_INT_MAX >= LONG_MAX
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = ( int ) lNumber;
pItem->item.asInteger.length = HB_INT_LENGTH( lNumber );
#else
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = ( HB_LONG ) lNumber;
pItem->item.asLong.length = HB_LONG_LENGTH( lNumber );
#endif
}
| hvm.c | 5455 |
STATIC VOID | hb_vmPushHBLong( HB_LONG lNumber )
static void hb_vmPushHBLong( HB_LONG lNumber )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushHBLong(%" PFHL "d)", lNumber));
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = lNumber;
pItem->item.asLong.length = HB_LONG_LENGTH( lNumber );
}
| hvm.c | 5472 |
STATIC VOID | hb_vmPushLongLongConst( LONGLONG llNumber )
static void hb_vmPushLongLongConst( LONGLONG llNumber )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushLongLongConst(%" PFLL "d)", llNumber));
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = ( HB_LONG ) llNumber;
pItem->item.asLong.length = hb_vmCalcIntWidth( llNumber );
}
| hvm.c | 5484 |
HB_EXPORT VOID | hb_vmPushNumInt( HB_LONG lNumber )
HB_EXPORT void hb_vmPushNumInt( HB_LONG lNumber )
{
if( HB_LIM_INT( lNumber ) )
hb_vmPushInteger( ( int ) lNumber );
else
hb_vmPushHBLong( lNumber );
}
| hvm.c | 5496 |
HB_EXPORT VOID | hb_vmPushDouble( double dNumber, int iDec )
HB_EXPORT void hb_vmPushDouble( double dNumber, int iDec )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushDouble(%lf, %d)", dNumber, iDec));
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value = dNumber;
pItem->item.asDouble.length = HB_DBL_LENGTH( dNumber );
if( iDec == HB_DEFAULT_DECIMALS )
pItem->item.asDouble.decimal = hb_set.HB_SET_DECIMALS;
else
pItem->item.asDouble.decimal = iDec;
}
| hvm.c | 5504 |
STATIC VOID | hb_vmPushDoubleConst( double dNumber, int iWidth, int iDec )
static void hb_vmPushDoubleConst( double dNumber, int iWidth, int iDec )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushDoubleConst(%lf, %d, %d)", dNumber, iWidth, iDec));
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value = dNumber;
if( iDec == HB_DEFAULT_DECIMALS )
pItem->item.asDouble.decimal = hb_set.HB_SET_DECIMALS;
else
pItem->item.asDouble.decimal = iDec;
if( iWidth == HB_DEFAULT_WIDTH )
pItem->item.asDouble.length = HB_DBL_LENGTH( dNumber );
else
pItem->item.asDouble.length = iWidth;
}
| hvm.c | 5519 |
HB_EXPORT VOID | hb_vmPushDate( long lDate )
HB_EXPORT void hb_vmPushDate( long lDate )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushDate(%ld)", lDate));
pItem->type = HB_IT_DATE;
pItem->item.asDate.value = lDate;
}
| hvm.c | 5539 |
HB_EXPORT VOID | hb_vmPushPointer( void * pPointer )
HB_EXPORT void hb_vmPushPointer( void * pPointer )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushPointer(%ld)", pPointer));
pItem->type = HB_IT_POINTER;
pItem->item.asPointer.value = pPointer;
pItem->item.asPointer.collect = FALSE;
}
| hvm.c | 5549 |
HB_EXPORT VOID | hb_vmPushString( const char * szText, ULONG length )
HB_EXPORT void hb_vmPushString( const char * szText, ULONG length )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushString(%s, %lu)", szText, length));
hb_itemPutCL( hb_stackAllocItem(), szText, length );
}
| hvm.c | 5560 |
HB_EXPORT VOID | hb_vmPushStringPcode( const char * szText, ULONG length )
HB_EXPORT void hb_vmPushStringPcode( const char * szText, ULONG length )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushStringPcode(%s, %lu)", szText, length));
pItem->type = HB_IT_STRING;
pItem->item.asString.length = length;
pItem->item.asString.allocated = 0;
pItem->item.asString.value = ( char * ) szText;
}
| hvm.c | 5567 |
HB_EXPORT VOID | hb_vmPushSymbol( PHB_SYMB pSym )
HB_EXPORT void hb_vmPushSymbol( PHB_SYMB pSym )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushSymbol(%p)", pSym));
pItem->type = HB_IT_SYMBOL;
pItem->item.asSymbol.value = pSym;
pItem->item.asSymbol.stackstate = NULL;
}
| hvm.c | 5579 |
HB_EXPORT VOID | hb_vmPushDynSym( PHB_DYNS pDynSym )
HB_EXPORT void hb_vmPushDynSym( PHB_DYNS pDynSym )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushDynSym(%p)", pDynSym));
pItem->type = HB_IT_SYMBOL;
pItem->item.asSymbol.value = pDynSym->pSymbol;
pItem->item.asSymbol.stackstate = NULL;
}
| hvm.c | 5590 |
HB_EXPORT VOID | hb_vmPushEvalSym( void )
HB_EXPORT void hb_vmPushEvalSym( void )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushEvalSym()"));
pItem->type = HB_IT_SYMBOL;
pItem->item.asSymbol.value = &hb_symEval;
pItem->item.asSymbol.stackstate = NULL;
}
| hvm.c | 5601 |
STATIC VOID | hb_vmPushBlock( const BYTE * pCode, PHB_SYMB pSymbols, ULONG ulLen )
static void hb_vmPushBlock( const BYTE * pCode, PHB_SYMB pSymbols, ULONG ulLen )
{
USHORT uiLocals;
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushBlock(%p,%p,%lu)", pCode, pSymbols, ulLen));
uiLocals = HB_PCODE_MKUSHORT( &pCode[ 2 ] );
if( ulLen )
ulLen -= uiLocals << 1;
pItem->item.asBlock.value =
hb_codeblockNew( pCode + 4 + ( uiLocals << 1 ),/* pcode buffer */
uiLocals, /* number of referenced local variables */
pCode + 4, /* table with referenced local variables */
pSymbols,
ulLen );
pItem->type = HB_IT_BLOCK;
/* store the number of expected parameters
*/
pItem->item.asBlock.paramcnt = HB_PCODE_MKUSHORT( pCode );
/* store the line number where the codeblock was defined
*/
pItem->item.asBlock.lineno = hb_stackBaseItem()->item.asSymbol.stackstate->uiLineNo;
pItem->item.asBlock.hclass = hb_stackBaseItem()->item.asSymbol.stackstate->uiClass;
pItem->item.asBlock.method = hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
}
| hvm.c | 5612 |
STATIC VOID | hb_vmPushBlockShort( const BYTE * pCode, PHB_SYMB pSymbols, ULONG ulLen )
static void hb_vmPushBlockShort( const BYTE * pCode, PHB_SYMB pSymbols, ULONG ulLen )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushBlockShort(%p,%p,%hu)", pCode, pSymbols, ulLen));
pItem->item.asBlock.value =
hb_codeblockNew( pCode, /* pcode buffer */
0, /* number of referenced local variables */
NULL, /* table with referenced local variables */
pSymbols,
ulLen );
pItem->type = HB_IT_BLOCK;
/* store the number of expected parameters
*/
pItem->item.asBlock.paramcnt = 0;
/* store the line number where the codeblock was defined
*/
pItem->item.asBlock.lineno = hb_stackBaseItem()->item.asSymbol.stackstate->uiLineNo;
pItem->item.asBlock.hclass = hb_stackBaseItem()->item.asSymbol.stackstate->uiClass;
pItem->item.asBlock.method = hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
}
| hvm.c | 5650 |
STATIC VOID | hb_vmPushMacroBlock( const BYTE * pCode, ULONG ulSize, USHORT usParams )
static void hb_vmPushMacroBlock( const BYTE * pCode, ULONG ulSize, USHORT usParams )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushMacroBlock(%p,%lu,%hu)", pCode, ulSize, usParams));
pItem->item.asBlock.value = hb_codeblockMacroNew( pCode, ulSize );
pItem->type = HB_IT_BLOCK;
/* store the number of expected parameters
*/
pItem->item.asBlock.paramcnt = usParams;
/* store the line number where the codeblock was defined
*/
pItem->item.asBlock.lineno = hb_stackBaseItem()->item.asSymbol.stackstate->uiLineNo;
pItem->item.asBlock.hclass = hb_stackBaseItem()->item.asSymbol.stackstate->uiClass;
pItem->item.asBlock.method = hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod;
}
| hvm.c | 5681 |
STATIC VOID | hb_vmPushAlias( void )
static void hb_vmPushAlias( void )
{
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushAlias()"));
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = hb_rddGetCurrentWorkAreaNumber();
pItem->item.asInteger.length = 10;
}
| hvm.c | 5707 |
STATIC VOID | hb_vmPushAliasedField( PHB_SYMB pSym )
static void hb_vmPushAliasedField( PHB_SYMB pSym )
{
PHB_ITEM pAlias;
int iCurrArea;
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushAliasedField(%p)", pSym));
iCurrArea = hb_rddGetCurrentWorkAreaNumber();
pAlias = hb_stackItemFromTop( -1 );
/*
* NOTE: hb_vmSelecWorkarea clears passed item
*/
if( hb_vmSelectWorkarea( pAlias, pSym ) == SUCCESS )
hb_rddGetFieldValue( pAlias, pSym );
hb_rddSelectWorkAreaNumber( iCurrArea );
}
| hvm.c | 5720 |
STATIC VOID | hb_vmPushAliasedVar( PHB_SYMB pSym )
static void hb_vmPushAliasedVar( PHB_SYMB pSym )
{
PHB_ITEM pAlias = hb_stackItemFromTop( -1 );
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushAliasedVar(%p)", pSym));
if( HB_IS_STRING( pAlias ) )
{
char * szAlias = pAlias->item.asString.value;
if( szAlias[ 0 ] == 'M' || szAlias[ 0 ] == 'm' )
{
if( pAlias->item.asString.length == 1 || /* M->variable */
( pAlias->item.asString.length >= 4 &&
hb_strnicmp( szAlias, "MEMVAR", /* MEMVAR-> or MEMVA-> or MEMV-> */
pAlias->item.asString.length ) == 0 ) )
{
hb_memvarGetValue( pAlias, pSym );
return;
}
}
else if( pAlias->item.asString.length >= 4 &&
hb_strnicmp( szAlias, "FIELD", /* FIELD-> or FIEL-> */
pAlias->item.asString.length ) == 0 )
{
hb_rddGetFieldValue( pAlias, pSym );
return;
}
}
hb_vmPushAliasedField( pSym );
}
| hvm.c | 5743 |
STATIC VOID | hb_vmPushLocal( int iLocal )
static void hb_vmPushLocal( int iLocal )
{
PHB_ITEM pLocal;
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushLocal(%d)", iLocal));
if( iLocal >= 0 )
{
/* local variable or local parameter */
pLocal = hb_stackLocalVariable( &iLocal );
}
else
{
/* local variable referenced in a codeblock
* hb_stackSelfItem() points to a codeblock that is currently evaluated
*/
pLocal = hb_codeblockGetRef( hb_stackSelfItem()->item.asBlock.value, ( LONG ) iLocal );
}
hb_itemCopy( hb_stackAllocItem(),
HB_IS_BYREF( pLocal ) ? hb_itemUnRef( pLocal ) : pLocal );
}
| hvm.c | 5781 |
STATIC VOID | hb_vmPushLocalByRef( int iLocal )
static void hb_vmPushLocalByRef( int iLocal )
{
HB_ITEM_PTR pTop = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushLocalByRef(%d)", iLocal));
/* we store its stack offset instead of a pointer to support a dynamic stack */
if( iLocal >= 0 )
{
PHB_ITEM pLocal = hb_stackLocalVariable( &iLocal );
if( HB_IS_BYREF( pLocal ) && !HB_IS_ENUM( pLocal ) )
{
hb_itemCopy( pTop, pLocal );
return;
}
pTop->item.asRefer.BasePtr.itemsbasePtr = hb_stackItemBasePtr();
}
else
{
/* store direct codeblock address because an item where a codeblock
* is stored can be no longer placed on the eval stack at the time
* of a codeblock evaluation or variable access
*/
pTop->item.asRefer.BasePtr.block = hb_stackSelfItem()->item.asBlock.value;
}
pTop->type = HB_IT_BYREF;
pTop->item.asRefer.value = iLocal;
pTop->item.asRefer.offset = hb_stackBaseOffset();
}
| hvm.c | 5804 |
STATIC VOID | hb_vmPushStatic( USHORT uiStatic )
static void hb_vmPushStatic( USHORT uiStatic )
{
PHB_ITEM pStatic;
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushStatic(%hu)", uiStatic));
pStatic = s_aStatics.item.asArray.value->pItems + hb_stackGetStaticsBase() + uiStatic - 1;
hb_itemCopy( hb_stackAllocItem(),
HB_IS_BYREF( pStatic ) ? hb_itemUnRef( pStatic ) : pStatic );
}
| hvm.c | 5834 |
STATIC VOID | hb_vmPushStaticByRef( USHORT uiStatic )
static void hb_vmPushStaticByRef( USHORT uiStatic )
{
HB_ITEM_PTR pTop = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushStaticByRef(%hu)", uiStatic));
pTop->type = HB_IT_BYREF;
/* we store the offset instead of a pointer to support a dynamic stack */
pTop->item.asRefer.value = hb_stackGetStaticsBase() + uiStatic - 1;
pTop->item.asRefer.offset = 0; /* 0 for static variables */
pTop->item.asRefer.BasePtr.array = s_aStatics.item.asArray.value;
hb_gcRefInc( s_aStatics.item.asArray.value );
}
| hvm.c | 5845 |
STATIC VOID | hb_vmPushVariable( PHB_SYMB pVarSymb )
static void hb_vmPushVariable( PHB_SYMB pVarSymb )
{
USHORT uiAction = E_DEFAULT;
PHB_ITEM pItem;
HB_TRACE(HB_TR_INFO, ("(hb_vmPushVariable)"));
pItem = hb_stackAllocItem();
do
{
/* First try if passed symbol is a name of field
* in a current workarea - if it is not a field (FAILURE)
* then try the memvar variable
*/
if( hb_rddFieldGet( pItem, pVarSymb ) != SUCCESS )
{
if( hb_memvarGet( pItem, pVarSymb ) != SUCCESS )
{
HB_ITEM_PTR pError;
pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, 1003,
NULL, pVarSymb->szName,
0, EF_CANRETRY );
uiAction = hb_errLaunch( pError );
hb_errRelease( pError );
}
}
}
while( uiAction == E_RETRY );
}
| hvm.c | 5858 |
STATIC VOID | hb_vmDuplicate( void )
static void hb_vmDuplicate( void )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_vmDuplicate()"));
pItem = hb_stackItemFromTop( -1 );
hb_itemCopy( hb_stackAllocItem(), pItem );
}
| hvm.c | 5892 |
STATIC VOID | hb_vmDuplUnRef( void )
static void hb_vmDuplUnRef( void )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_vmDuplUnRef()"));
pItem = hb_stackItemFromTop( -1 );
hb_itemCopy( hb_stackAllocItem(), pItem );
if( HB_IS_BYREF( pItem ) )
hb_itemCopy( pItem, hb_itemUnRef( pItem ) );
}
| hvm.c | 5902 |
STATIC VOID | hb_vmDuplTwo( void )
static void hb_vmDuplTwo( void )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_vmDuplTwo()"));
pItem = hb_stackItemFromTop( -2 );
hb_itemCopy( hb_stackAllocItem(), pItem );
pItem = hb_stackItemFromTop( -2 );
hb_itemCopy( hb_stackAllocItem(), pItem );
}
| hvm.c | 5914 |
STATIC VOID | hb_vmPushUnRef( void )
static void hb_vmPushUnRef( void )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushUnRef()"));
pItem = hb_stackItemFromTop( -1 );
hb_itemCopy( hb_stackAllocItem(),
HB_IS_BYREF( pItem ) ? hb_itemUnRef( pItem ) : pItem );
}
| hvm.c | 5926 |
STATIC VOID | hb_vmSwap( BYTE bCount )
static void hb_vmSwap( BYTE bCount )
{
int i = -1;
HB_TRACE(HB_TR_DEBUG, ("hb_vmSwap(%d)", bCount));
do
{
hb_itemSwap( hb_stackItemFromTop( i ), hb_stackItemFromTop( i - 1 ) );
--i;
}
while( bCount-- );
}
/* ------------------------------- */
/* Pop */
| hvm.c | 5937 |
HB_EXPORT VOID | hb_vmPopState( void )
HB_EXPORT void hb_vmPopState( void )
{
HB_TRACE_STEALTH( HB_TR_DEBUG, ( "hb_vmPopState()" ) );
hb_stackPopReturn();
}
| hvm.c | 5955 |
STATIC BOOL | hb_vmPopLogical( void )
static BOOL hb_vmPopLogical( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmPopLogical()"));
if( HB_IS_LOGICAL( hb_stackItemFromTop( -1 ) ) )
{
BOOL fValue = hb_stackItemFromTop( -1 )->item.asLogical.value;
hb_stackDec();
return fValue;
}
else
{
hb_errRT_BASE( EG_ARG, 1066, NULL, hb_langDGetErrorDesc( EG_CONDITION ), 1, hb_stackItemFromTop( -1 ) );
return FALSE;
}
}
| hvm.c | 5962 |
STATIC DOUBLE | hb_vmPopNumber( void )
static double hb_vmPopNumber( void )
{
PHB_ITEM pItem;
double dNumber;
HB_TRACE(HB_TR_DEBUG, ("hb_vmPopNumber()"));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_INTEGER( pItem ) )
dNumber = ( double ) pItem->item.asInteger.value;
else if( HB_IS_LONG( pItem ) )
dNumber = ( double ) pItem->item.asLong.value;
else if( HB_IS_DOUBLE( pItem ) )
dNumber = pItem->item.asDouble.value;
else
{
hb_errInternal( HB_EI_VMPOPINVITEM, NULL, "hb_vmPopNumber()", NULL );
dNumber = 0.0; /* To avoid GCC -O2 warning */
}
hb_stackDec();
return dNumber;
}
| hvm.c | 5982 |
STATIC VOID | hb_vmPopAlias( void )
static void hb_vmPopAlias( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmPopAlias()"));
hb_vmSelectWorkarea( hb_stackItemFromTop( -1 ), NULL ); /* it clears the passed item */
hb_stackDec();
}
| hvm.c | 6011 |
STATIC VOID | hb_vmPopAliasedField( PHB_SYMB pSym )
static void hb_vmPopAliasedField( PHB_SYMB pSym )
{
int iCurrArea;
HB_TRACE(HB_TR_DEBUG, ("hb_vmPopAliasedField(%p)", pSym));
iCurrArea = hb_rddGetCurrentWorkAreaNumber();
if( hb_vmSelectWorkarea( hb_stackItemFromTop( -1 ), pSym ) == SUCCESS )
hb_rddPutFieldValue( hb_stackItemFromTop( -2 ), pSym );
hb_rddSelectWorkAreaNumber( iCurrArea );
hb_stackDec(); /* alias - it was cleared in hb_vmSelectWorkarea */
hb_stackPop(); /* field value */
}
| hvm.c | 6022 |
STATIC VOID | hb_vmPopAliasedVar( PHB_SYMB pSym )
static void hb_vmPopAliasedVar( PHB_SYMB pSym )
{
HB_ITEM_PTR pAlias = hb_stackItemFromTop( -1 );
HB_TRACE(HB_TR_DEBUG, ("hb_vmPopAliasedVar(%p)", pSym));
/*
* "M", "MEMV" - "MEMVAR" and "FIEL" - "FIELD" are reserved aliases
*/
if( HB_IS_STRING( pAlias ) )
{
char * szAlias = pAlias->item.asString.value;
if( szAlias[ 0 ] == 'M' || szAlias[ 0 ] == 'm' )
{
if( pAlias->item.asString.length == 1 || /* M->variable */
( pAlias->item.asString.length >= 4 &&
hb_strnicmp( szAlias, "MEMVAR", /* MEMVAR-> or MEMVA-> or MEMV-> */
pAlias->item.asString.length ) == 0 ) )
{
hb_memvarSetValue( pSym, hb_stackItemFromTop( -2 ) );
hb_stackPop(); /* alias */
hb_stackPop(); /* value */
return;
}
}
else if( pAlias->item.asString.length >= 4 &&
hb_strnicmp( szAlias, "FIELD", /* FIELD-> or FIEL-> */
pAlias->item.asString.length ) == 0 )
{
hb_rddPutFieldValue( hb_stackItemFromTop( -2 ), pSym );
hb_stackPop(); /* alias */
hb_stackPop(); /* value */
return;
}
}
hb_vmPopAliasedField( pSym );
}
| hvm.c | 6040 |
STATIC VOID | hb_vmPopLocal( int iLocal )
static void hb_vmPopLocal( int iLocal )
{
PHB_ITEM pLocal, pVal;
HB_TRACE(HB_TR_DEBUG, ("hb_vmPopLocal(%d)", iLocal));
pVal = hb_stackItemFromTop( -1 );
/* Remove MEMOFLAG if exists (assignment from field). */
pVal->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT );
if( iLocal >= 0 )
{
/* local variable or local parameter */
pLocal = hb_stackLocalVariable( &iLocal );
}
else
{
/* local variable referenced in a codeblock
* hb_stackSelfItem() points to a codeblock that is currently evaluated
*/
pLocal = hb_codeblockGetRef( hb_stackSelfItem()->item.asBlock.value, iLocal );
}
hb_itemMoveToRef( pLocal, pVal );
hb_stackDec();
}
| hvm.c | 6084 |
STATIC VOID | hb_vmPopStatic( USHORT uiStatic )
static void hb_vmPopStatic( USHORT uiStatic )
{
PHB_ITEM pStatic, pVal;
HB_TRACE(HB_TR_DEBUG, ("hb_vmPopStatic(%hu)", uiStatic));
pVal = hb_stackItemFromTop( -1 );
/* Remove MEMOFLAG if exists (assignment from field). */
pVal->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT );
pStatic = s_aStatics.item.asArray.value->pItems + hb_stackGetStaticsBase() + uiStatic - 1;
hb_itemMoveToRef( pStatic, pVal );
hb_stackDec();
}
/* ----------------------------------------------- */
| hvm.c | 6113 |
PHB_SYMB | hb_vmGetRealFuncSym( PHB_SYMB pSym )
PHB_SYMB hb_vmGetRealFuncSym( PHB_SYMB pSym )
{
if( pSym && !( pSym->scope.value & HB_FS_LOCAL ) )
{
pSym = pSym->pDynSym &&
( pSym->pDynSym->pSymbol->scope.value & HB_FS_LOCAL ) ?
pSym->pDynSym->pSymbol : NULL;
}
return pSym;
}
| hvm.c | 6135 |
CHAR * | hb_vmFindModuleSymbolName( PHB_SYMB pSym )
char * hb_vmFindModuleSymbolName( PHB_SYMB pSym )
{
if( pSym )
{
PHB_SYMBOLS pLastSymbols = s_pSymbols;
while( pLastSymbols )
{
if( pLastSymbols->fActive &&
pSym >= pLastSymbols->pModuleSymbols &&
pSym < pLastSymbols->pModuleSymbols + pLastSymbols->uiModuleSymbols )
{
return pLastSymbols->szModuleName;
}
pLastSymbols = pLastSymbols->pNext;
}
}
return NULL;
}
| hvm.c | 6147 |
BOOL | hb_vmFindModuleSymbols( PHB_SYMB pSym, PHB_SYMB * pSymbols, USHORT * puiSymbols )
BOOL hb_vmFindModuleSymbols( PHB_SYMB pSym, PHB_SYMB * pSymbols,
USHORT * puiSymbols )
{
if( pSym )
{
PHB_SYMBOLS pLastSymbols = s_pSymbols;
/*
if( pSym->scope.value & HB_FS_PCODEFUNC )
* pSymbols = pSym->value.pCodeFunc->pSymbols;
*/
while( pLastSymbols )
{
if( pLastSymbols->fActive &&
pSym >= pLastSymbols->pModuleSymbols &&
pSym < pLastSymbols->pModuleSymbols + pLastSymbols->uiModuleSymbols )
{
* pSymbols = pLastSymbols->pModuleSymbols;
* puiSymbols = pLastSymbols->uiModuleSymbols;
return TRUE;
}
pLastSymbols = pLastSymbols->pNext;
}
}
* pSymbols = NULL;
* puiSymbols = 0;
return FALSE;
}
| hvm.c | 6167 |
STATIC PHB_SYMBOLS | hb_vmFindFreeModule( PHB_SYMB pSymbols, USHORT uiSymbols, char * szModuleName, ULONG ulID )
static PHB_SYMBOLS hb_vmFindFreeModule( PHB_SYMB pSymbols, USHORT uiSymbols,
char * szModuleName, ULONG ulID )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmFindFreeModule(%p,%hu,%s,%lu)", pSymbols, uiSymbols, szModuleName, ulID));
if( s_ulFreeSymbols )
{
PHB_SYMBOLS pLastSymbols = s_pSymbols;
while( pLastSymbols )
{
if( !pLastSymbols->fActive &&
pLastSymbols->ulID == ulID &&
pLastSymbols->uiModuleSymbols == uiSymbols &&
pLastSymbols->szModuleName != NULL &&
strcmp( pLastSymbols->szModuleName, szModuleName ) == 0 )
{
PHB_SYMB pModuleSymbols = pLastSymbols->pModuleSymbols;
USHORT ui;
for( ui = 0; ui < uiSymbols; ++ui )
{
if( ( pSymbols[ ui ].scope.value & ~( HB_FS_PCODEFUNC | HB_FS_DYNCODE ) ) !=
( pModuleSymbols[ ui ].scope.value & ~HB_FS_DEFERRED ) ||
strcmp( pSymbols[ ui ].szName, pModuleSymbols[ ui ].szName ) != 0 )
{
break;
}
}
if( ui == uiSymbols )
{
--s_ulFreeSymbols;
return pLastSymbols;
}
}
pLastSymbols = pLastSymbols->pNext;
}
}
return NULL;
}
| hvm.c | 6198 |
VOID | hb_vmFreeSymbols( PHB_SYMBOLS pSymbols )
void hb_vmFreeSymbols( PHB_SYMBOLS pSymbols )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmFreeSymbols(%p)", pSymbols));
if( pSymbols->fActive )
{
USHORT ui;
for( ui = 0; ui < pSymbols->uiModuleSymbols; ++ui )
{
HB_SYMBOLSCOPE scope = pSymbols->pModuleSymbols[ ui ].scope.value & HB_FS_INITEXIT;
/* do not overwrite already initialized statics' frame */
if( scope != HB_FS_INITEXIT )
{
PHB_SYMB pSymbol = &pSymbols->pModuleSymbols[ ui ];
pSymbol->value.pFunPtr = NULL;
if( pSymbol->pDynSym && pSymbol->pDynSym->pSymbol != pSymbol &&
( pSymbol->scope.value & HB_FS_LOCAL ) == 0 )
pSymbol->scope.value |= HB_FS_DEFERRED;
}
pSymbols->pModuleSymbols[ ui ].scope.value &= ~( HB_FS_PCODEFUNC | HB_FS_DYNCODE );
}
pSymbols->hDynLib = NULL;
pSymbols->fActive = FALSE;
++s_ulFreeSymbols;
}
}
| hvm.c | 6240 |
VOID | hb_vmBeginSymbolGroup( void * hDynLib, BOOL fClone )
void hb_vmBeginSymbolGroup( void * hDynLib, BOOL fClone )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmBeginSymbolGroup(%p,%d)", hDynLib, (int)fClone));
s_hDynLibID = hDynLib;
s_fCloneSym = fClone;
}
| hvm.c | 6269 |
VOID | hb_vmInitSymbolGroup( void * hNewDynLib, int argc, char * argv[] )
void hb_vmInitSymbolGroup( void * hNewDynLib, int argc, char * argv[] )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmInitSymbolGroup(%p,%d,%p)", hNewDynLib, argc, argv));
s_fCloneSym = FALSE;
if( s_hDynLibID )
{
PHB_SYMBOLS pLastSymbols = s_pSymbols;
void * hDynLib = s_hDynLibID;
BOOL fFound = FALSE;
USHORT ui;
s_hDynLibID = NULL;
while( pLastSymbols )
{
if( pLastSymbols->hDynLib == hDynLib )
{
fFound = TRUE;
if( pLastSymbols->fInitStatics && pLastSymbols->fActive )
{
for( ui = 0; ui < pLastSymbols->uiModuleSymbols; ui++ )
{
HB_SYMBOLSCOPE scope = ( pLastSymbols->pModuleSymbols + ui )->scope.value & HB_FS_INITEXIT;
if( scope == HB_FS_INITEXIT )
{
hb_vmPushSymbol( pLastSymbols->pModuleSymbols + ui );
hb_vmPushNil();
hb_vmDo( 0 );
}
}
pLastSymbols->fInitStatics = FALSE;
}
pLastSymbols->hDynLib = hNewDynLib;
}
pLastSymbols = pLastSymbols->pNext;
}
if( fFound )
{
pLastSymbols = s_pSymbols;
while( pLastSymbols )
{
if( pLastSymbols->hDynLib == hNewDynLib )
{
if( pLastSymbols->fActive && ( pLastSymbols->hScope & HB_FS_INIT ) != 0 )
{
for( ui = 0; ui < pLastSymbols->uiModuleSymbols; ui++ )
{
HB_SYMBOLSCOPE scope = ( pLastSymbols->pModuleSymbols + ui )->scope.value & HB_FS_INITEXIT;
if( scope == HB_FS_INIT )
{
int i;
hb_vmPushSymbol( pLastSymbols->pModuleSymbols + ui );
hb_vmPushNil();
for( i = 0; i < argc; ++i )
{
hb_vmPushString( argv[i], strlen( argv[i] ) );
}
hb_vmDo( argc );
}
}
}
}
pLastSymbols = pLastSymbols->pNext;
}
}
}
}
| hvm.c | 6277 |
VOID | hb_vmExitSymbolGroup( void * hDynLib )
void hb_vmExitSymbolGroup( void * hDynLib )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmExitSymbolGroup(%p)", hDynLib));
if( hDynLib )
{
PHB_SYMBOLS pLastSymbols = s_pSymbols;
BOOL fFound = FALSE;
while( pLastSymbols )
{
if( pLastSymbols->hDynLib == hDynLib )
{
fFound = TRUE;
if( pLastSymbols->fActive && ( pLastSymbols->hScope & HB_FS_EXIT ) != 0 )
{
USHORT ui;
for( ui = 0; ui < pLastSymbols->uiModuleSymbols; ui++ )
{
HB_SYMBOLSCOPE scope = ( pLastSymbols->pModuleSymbols + ui )->scope.value & HB_FS_INITEXIT;
if( scope == HB_FS_EXIT )
{
hb_vmPushSymbol( pLastSymbols->pModuleSymbols + ui );
hb_vmPushNil();
hb_vmDo( 0 );
}
}
}
}
pLastSymbols = pLastSymbols->pNext;
}
if( fFound )
{
pLastSymbols = s_pSymbols;
while( pLastSymbols )
{
if( pLastSymbols->hDynLib == hDynLib )
{
hb_vmFreeSymbols( pLastSymbols );
}
pLastSymbols = pLastSymbols->pNext;
}
}
}
}
| hvm.c | 6352 |
PHB_SYMBOLS | hb_vmRegisterSymbols( PHB_SYMB pModuleSymbols, USHORT uiSymbols, char * szModuleName, ULONG ulID, BOOL fDynLib, BOOL fClone )
PHB_SYMBOLS hb_vmRegisterSymbols( PHB_SYMB pModuleSymbols, USHORT uiSymbols,
char * szModuleName, ULONG ulID,
BOOL fDynLib, BOOL fClone )
{
PHB_SYMBOLS pNewSymbols;
BOOL fRecycled, fInitStatics = FALSE;
USHORT ui;
HB_TRACE(HB_TR_DEBUG, ("hb_vmRegisterSymbols(%p,%hu,%s,%lu,%d,%d)", pModuleSymbols, uiSymbols, szModuleName, ulID, (int)fDynLib, (int)fClone));
pNewSymbols = s_ulFreeSymbols == 0 ? NULL :
hb_vmFindFreeModule( pModuleSymbols, uiSymbols, szModuleName, ulID );
if( pNewSymbols )
{
pNewSymbols->fActive = fRecycled = TRUE;
pNewSymbols->hDynLib = s_hDynLibID;
pNewSymbols->hScope = 0;
}
else
{
fRecycled = FALSE;
if( fClone )
{
PHB_SYMB pSymbols = ( PHB_SYMB ) hb_xgrab( uiSymbols * sizeof( HB_SYMB ) );
memcpy( pSymbols, pModuleSymbols, uiSymbols * sizeof( HB_SYMB ) );
for( ui = 0; ui < uiSymbols; ui++ )
{
pSymbols[ ui ].szName = hb_strdup( pSymbols[ ui ].szName );
}
pModuleSymbols = pSymbols;
}
pNewSymbols = ( PHB_SYMBOLS ) hb_xgrab( sizeof( HB_SYMBOLS ) );
pNewSymbols->pModuleSymbols = pModuleSymbols;
pNewSymbols->uiModuleSymbols = uiSymbols;
pNewSymbols->szModuleName = hb_strdup( szModuleName );
pNewSymbols->ulID = ulID;
pNewSymbols->fAllocated = fClone;
pNewSymbols->fActive = TRUE;
pNewSymbols->fInitStatics = FALSE;
pNewSymbols->hDynLib = s_hDynLibID;
pNewSymbols->hScope = 0;
pNewSymbols->pNext = NULL;
if( s_pSymbols == NULL )
{
s_pSymbols = pNewSymbols;
}
else
{
PHB_SYMBOLS pLastSymbols = s_pSymbols;
while( pLastSymbols->pNext ) /* locates the latest processed group of symbols */
pLastSymbols = pLastSymbols->pNext;
pLastSymbols->pNext = pNewSymbols;
}
}
for( ui = 0; ui < uiSymbols; ui++ ) /* register each public symbol on the dynamic symbol table */
{
PHB_SYMB pSymbol = pNewSymbols->pModuleSymbols + ui;
HB_SYMBOLSCOPE hSymScope;
BOOL fPublic, fStatics;
fStatics = ( pSymbol->scope.value & HB_FS_INITEXIT ) == HB_FS_INITEXIT;
if( fRecycled && !fStatics )
{
pSymbol->value.pFunPtr = ( pModuleSymbols + ui )->value.pFunPtr;
pSymbol->scope.value = ( pModuleSymbols + ui )->scope.value;
}
if( fDynLib )
{
pSymbol->scope.value |= HB_FS_DYNCODE;
}
hSymScope = pSymbol->scope.value;
pNewSymbols->hScope |= hSymScope;
/* fPublic = ( hSymScope & ( HB_FS_PUBLIC | HB_FS_MESSAGE | HB_FS_MEMVAR ) ) != 0; */
fPublic = ( hSymScope & ( HB_FS_INITEXIT | HB_FS_STATIC ) ) == 0;
if( fStatics )
{
fInitStatics = TRUE;
}
if( ( hSymScope & HB_FS_PCODEFUNC ) && ( hSymScope & HB_FS_LOCAL ) &&
( fRecycled || fClone ) )
{
pSymbol->value.pCodeFunc->pSymbols = pNewSymbols->pModuleSymbols;
}
if( !s_pSymStart && !fDynLib &&
( hSymScope & HB_FS_FIRST ) != 0 &&
( hSymScope & HB_FS_INITEXIT ) == 0 )
{
/* first public defined symbol to start execution */
s_pSymStart = pSymbol;
}
/* Enable this code to see static functions which are registered in global dynsym table */
#if 0
if( fPublic && ( hSymScope & ( HB_FS_INITEXIT | HB_FS_STATIC ) ) != 0 )
{
printf("Registring: %s:%s scope %04x\r\n", szModuleName, pSymbol->szName, hSymScope ); fflush(stdout);
}
#endif
if( fPublic )
{
if( fDynLib && pSymbol->value.pFunPtr )
{
PHB_DYNS pDynSym;
pDynSym = hb_dynsymFind( pSymbol->szName );
if( pDynSym )
{
pSymbol->pDynSym = pDynSym;
if( pDynSym->pSymbol->value.pFunPtr )
{
pSymbol->scope.value =
( pSymbol->scope.value & ~( HB_FS_PCODEFUNC | HB_FS_LOCAL ) ) |
( pDynSym->pSymbol->scope.value & HB_FS_PCODEFUNC );
pSymbol->value.pFunPtr = pDynSym->pSymbol->value.pFunPtr;
}
else
{
pDynSym->pSymbol = pSymbol;
}
continue;
}
}
hb_dynsymNew( pSymbol );
}
}
if( !fRecycled )
{
pNewSymbols->fInitStatics = fInitStatics;
}
return pNewSymbols;
}
| hvm.c | 6400 |
HB_EXPORT PHB_SYMB | hb_vmProcessSymbolsEx( PHB_SYMB pSymbols, USHORT uiModuleSymbols, char * szModuleName, ULONG ulID, USHORT uiPCodeVer )
HB_EXPORT PHB_SYMB hb_vmProcessSymbolsEx( PHB_SYMB pSymbols, USHORT uiModuleSymbols,
char * szModuleName, ULONG ulID,
USHORT uiPCodeVer )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmProcessSymbolsEx(%p,%hu,%s,%lu,%hu)", pSymbols, uiModuleSymbols, szModuleName, ulID, uiPCodeVer));
if( uiPCodeVer != 0 )
{
if( uiPCodeVer > HB_PCODE_VER || /* the module is compiled with newer compiler version then HVM */
uiPCodeVer < HB_PCODE_VER_MIN ) /* the module is compiled with old not longer supported by HVM compiler version */
{
char szPCode[ 10 ];
snprintf( szPCode, sizeof( szPCode ), "%i.%i", uiPCodeVer>>8, uiPCodeVer &0xff );
hb_errInternal( HB_EI_ERRUNRECOV, "Module '%s'\n"
"was compiled with unsupported PCODE version %s.\n"
"Please recompile.", szModuleName, szPCode );
}
}
return hb_vmRegisterSymbols( pSymbols, uiModuleSymbols, szModuleName, ulID,
s_fCloneSym, s_fCloneSym )->pModuleSymbols;
}
| hvm.c | 6547 |
HB_EXPORT PHB_SYMB | hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols )
HB_EXPORT PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmProcessSymbols(%p,%hu)", pSymbols, uiSymbols));
return hb_vmRegisterSymbols( pSymbols, uiSymbols, "", 0L,
s_fCloneSym, s_fCloneSym )->pModuleSymbols;
}
| hvm.c | 6574 |
HB_EXPORT PHB_SYMB | hb_vmProcessDllSymbols( PHB_SYMB pSymbols, USHORT uiModuleSymbols )
HB_EXPORT PHB_SYMB hb_vmProcessDllSymbols( PHB_SYMB pSymbols, USHORT uiModuleSymbols )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmProcessDllSymbols(%p,%hu)", pSymbols, uiModuleSymbols));
return hb_vmRegisterSymbols( pSymbols, uiModuleSymbols, "", 0,
TRUE, s_fCloneSym )->pModuleSymbols;
}
| hvm.c | 6585 |
STATIC VOID | hb_vmReleaseLocalSymbols( void )
static void hb_vmReleaseLocalSymbols( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmReleaseLocalSymbols()"));
while( s_pSymbols )
{
PHB_SYMBOLS pDestroy;
pDestroy = s_pSymbols;
s_pSymbols = s_pSymbols->pNext;
if( pDestroy->szModuleName )
{
hb_xfree( pDestroy->szModuleName );
}
if( pDestroy->fAllocated )
{
USHORT ui;
for( ui = 0; ui < pDestroy->uiModuleSymbols; ++ui )
{
PHB_SYMB pSymbol = pDestroy->pModuleSymbols + ui;
if( pSymbol->pDynSym && pSymbol->pDynSym->pSymbol == pSymbol )
{
pSymbol->pDynSym->pSymbol = NULL;
}
hb_xfree( ( void * ) pSymbol->szName );
}
hb_xfree( pDestroy->pModuleSymbols );
}
hb_xfree( pDestroy );
}
}
| hvm.c | 6596 |
STATIC VOID | hb_vmDoInitStatics( void )
static void hb_vmDoInitStatics( void )
{
PHB_SYMBOLS pLastSymbols = s_pSymbols;
HB_TRACE(HB_TR_DEBUG, ("hb_vmDoInitStatics()"));
while( pLastSymbols )
{
if( pLastSymbols->fInitStatics )
{
USHORT ui;
for( ui = 0; ui < pLastSymbols->uiModuleSymbols; ui++ )
{
HB_SYMBOLSCOPE scope = ( pLastSymbols->pModuleSymbols + ui )->scope.value & ( HB_FS_EXIT | HB_FS_INIT );
if( scope == HB_FS_INITEXIT )
{
hb_vmPushSymbol( pLastSymbols->pModuleSymbols + ui );
hb_vmPushNil();
hb_vmDo( 0 );
}
}
pLastSymbols->fInitStatics = FALSE;
}
pLastSymbols = pLastSymbols->pNext;
}
}
| hvm.c | 6629 |
STATIC VOID | hb_vmDoInitFunctions( void )
static void hb_vmDoInitFunctions( void )
{
PHB_SYMBOLS pLastSymbols = s_pSymbols;
HB_TRACE(HB_TR_DEBUG, ("hb_vmDoInitFunctions()"));
while( pLastSymbols )
{
/* only if module contains some INIT functions */
if( pLastSymbols->fActive && pLastSymbols->hScope & HB_FS_INIT )
{
USHORT ui;
for( ui = 0; ui < pLastSymbols->uiModuleSymbols; ui++ )
{
HB_SYMBOLSCOPE scope = ( pLastSymbols->pModuleSymbols + ui )->scope.value & ( HB_FS_EXIT | HB_FS_INIT );
if( scope == HB_FS_INIT )
{
int argc = hb_cmdargARGC();
char ** argv = hb_cmdargARGV();
int i;
int iArgCount;
hb_vmPushSymbol( pLastSymbols->pModuleSymbols + ui );
hb_vmPushNil();
iArgCount = 0;
for( i = 1; i < argc; i++ ) /* places application parameters on the stack */
{
/* Filter out any parameters beginning with //, like //INFO */
if( ! hb_cmdargIsInternal( argv[ i ], NULL ) )
{
hb_vmPushString( argv[ i ], strlen( argv[ i ] ) );
iArgCount++;
}
}
hb_vmDo( iArgCount );
}
}
}
pLastSymbols = pLastSymbols->pNext;
}
}
| hvm.c | 6663 |
STATIC VOID | hb_vmDoExitFunctions( void )
static void hb_vmDoExitFunctions( void )
{
PHB_SYMBOLS pLastSymbols = s_pSymbols;
HB_TRACE(HB_TR_DEBUG, ("hb_vmDoExitFunctions()"));
/* EXIT procedures should be processed? */
if( s_fDoExitProc )
{
s_fDoExitProc = FALSE;
hb_stackSetActionRequest( 0 );
while( pLastSymbols )
{
/* only if module contains some EXIT functions */
if( pLastSymbols->fActive && pLastSymbols->hScope & HB_FS_EXIT )
{
USHORT ui;
for( ui = 0; ui < pLastSymbols->uiModuleSymbols; ui++ )
{
HB_SYMBOLSCOPE scope = ( pLastSymbols->pModuleSymbols + ui )->scope.value & ( HB_FS_EXIT | HB_FS_INIT );
if( scope == HB_FS_EXIT )
{
hb_vmPushSymbol( pLastSymbols->pModuleSymbols + ui );
hb_vmPushNil();
hb_vmDo( 0 );
if( hb_stackGetActionRequest() )
/* QUIT or BREAK was issued - stop processing
*/
return;
}
}
}
pLastSymbols = pLastSymbols->pNext;
}
}
}
/* ------------------------------- */
/* Extended references */
| hvm.c | 6710 |
STATIC PHB_ITEM | hb_vmItemRefRead( PHB_ITEM pRefer )
static PHB_ITEM hb_vmItemRefRead( PHB_ITEM pRefer )
{
return ( PHB_ITEM ) pRefer->item.asExtRef.value;
}
| hvm.c | 6754 |
STATIC PHB_ITEM | hb_vmItemRefWrite( PHB_ITEM pRefer, PHB_ITEM pSource )
static PHB_ITEM hb_vmItemRefWrite( PHB_ITEM pRefer, PHB_ITEM pSource )
{
HB_SYMBOL_UNUSED( pSource );
return ( PHB_ITEM ) pRefer->item.asExtRef.value;
}
| hvm.c | 6762 |
STATIC VOID | hb_vmItemRefCopy( PHB_ITEM pDest )
static void hb_vmItemRefCopy( PHB_ITEM pDest )
{
pDest->type = HB_IT_NIL;
hb_itemCopy( pDest, ( PHB_ITEM ) pDest->item.asExtRef.value );
}
| hvm.c | 6768 |
STATIC VOID | hb_vmItemRefDummy( void * value )
static void hb_vmItemRefDummy( void * value )
{
HB_SYMBOL_UNUSED( value );
}
| hvm.c | 6774 |
HB_EXPORT VOID | hb_vmPushItemRef( PHB_ITEM pItem )
HB_EXPORT void hb_vmPushItemRef( PHB_ITEM pItem )
{
static const HB_EXTREF s_ItmExtRef = {
hb_vmItemRefRead,
hb_vmItemRefWrite,
hb_vmItemRefCopy,
hb_vmItemRefDummy,
hb_vmItemRefDummy };
PHB_ITEM pRefer;
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushItemRef(%p)", pItem));
pRefer = hb_stackAllocItem();
pRefer->type = HB_IT_BYREF | HB_IT_EXTREF;
pRefer->item.asExtRef.value = ( void * ) pItem;
pRefer->item.asExtRef.func = &s_ItmExtRef;
}
/* ------------------------------- */
/*
* extended message reference structure
*/
typedef struct
{
PHB_DYNS access;
PHB_DYNS assign;
HB_ITEM object;
HB_ITEM value;
} HB_MSGREF, * PHB_MSGREF;
| hvm.c | 6779 |
STATIC PHB_ITEM | hb_vmMsgRefRead( PHB_ITEM pRefer )
static PHB_ITEM hb_vmMsgRefRead( PHB_ITEM pRefer )
{
PHB_MSGREF pMsgRef = ( PHB_MSGREF ) pRefer->item.asExtRef.value;
if( hb_vmRequestQuery() == 0 )
{
hb_stackPushReturn();
if( !pMsgRef->access )
pMsgRef->access = hb_dynsymGetCase( pMsgRef->assign->pSymbol->szName + 1 );
hb_vmPushDynSym( pMsgRef->access );
hb_vmPush( &pMsgRef->object );
hb_vmSend( 0 );
hb_itemMove( &pMsgRef->value, hb_stackReturnItem() );
pMsgRef->value.type |= HB_IT_DEFAULT;
hb_stackPopReturn();
}
return &pMsgRef->value;
}
| hvm.c | 6814 |
STATIC PHB_ITEM | hb_vmMsgRefWrite( PHB_ITEM pRefer, PHB_ITEM pSource )
static PHB_ITEM hb_vmMsgRefWrite( PHB_ITEM pRefer, PHB_ITEM pSource )
{
PHB_MSGREF pMsgRef = ( PHB_MSGREF ) pRefer->item.asExtRef.value;
if( hb_vmRequestQuery() == 0 )
{
hb_stackPushReturn();
hb_vmPushDynSym( pMsgRef->assign );
hb_vmPush( &pMsgRef->object );
hb_vmPush( pSource );
hb_vmSend( 1 );
hb_itemCopy( &pMsgRef->value, pSource );
pMsgRef->value.type |= HB_IT_DEFAULT;
hb_stackPopReturn();
}
return NULL; /*&pMsgIdxRef->value;*/
}
| hvm.c | 6836 |
STATIC VOID | hb_vmMsgRefCopy( PHB_ITEM pDest )
static void hb_vmMsgRefCopy( PHB_ITEM pDest )
{
hb_xRefInc( pDest->item.asExtRef.value );
}
| hvm.c | 6854 |
STATIC VOID | hb_vmMsgRefClear( void * value )
static void hb_vmMsgRefClear( void * value )
{
if( hb_xRefDec( value ) )
{
PHB_MSGREF pMsgRef = ( PHB_MSGREF ) value;
/* value were change by C code without calling RefWrite(),
* f.e. hb_stor*() function
*/
if( ( pMsgRef->value.type & HB_IT_DEFAULT ) == 0 )
{
if( hb_vmRequestReenter() )
{
hb_vmPushDynSym( pMsgRef->assign );
hb_vmPush( &pMsgRef->object );
hb_vmPush( &pMsgRef->value );
hb_vmSend( 1 );
hb_vmRequestRestore();
}
}
if( HB_IS_COMPLEX( &pMsgRef->value ) )
hb_itemClear( &pMsgRef->value );
if( HB_IS_COMPLEX( &pMsgRef->object ) )
hb_itemClear( &pMsgRef->object );
hb_xfree( value );
}
}
| hvm.c | 6859 |
STATIC VOID | hb_vmMsgRefMark( void * value )
static void hb_vmMsgRefMark( void * value )
{
if( HB_IS_GCITEM( &( ( PHB_MSGREF ) value )->object ) )
hb_gcItemRef( &( ( PHB_MSGREF ) value )->object );
if( HB_IS_GCITEM( &( ( PHB_MSGREF ) value )->value ) )
hb_gcItemRef( &( ( PHB_MSGREF ) value )->value );
}
| hvm.c | 6886 |
BOOL | hb_vmMsgReference( PHB_ITEM pObject, PHB_DYNS pMessage, PHB_DYNS pAccMsg )
BOOL hb_vmMsgReference( PHB_ITEM pObject, PHB_DYNS pMessage, PHB_DYNS pAccMsg )
{
static const HB_EXTREF s_MsgExtRef = {
hb_vmMsgRefRead,
hb_vmMsgRefWrite,
hb_vmMsgRefCopy,
hb_vmMsgRefClear,
hb_vmMsgRefMark };
PHB_MSGREF pMsgRef;
PHB_ITEM pRefer;
HB_TRACE(HB_TR_DEBUG, ("hb_vmMsgReference(%p,%p,%p)", pObject, pMessage, pAccMsg));
pMsgRef = ( PHB_MSGREF ) hb_xgrab( sizeof( HB_MSGREF ) );
pMsgRef->access = pAccMsg;
pMsgRef->assign = pMessage;
pMsgRef->value.type = HB_IT_NIL | HB_IT_DEFAULT;
pMsgRef->object.type = HB_IT_NIL;
hb_itemMove( &pMsgRef->object, pObject );
pRefer = hb_stackReturnItem();
pRefer->type = HB_IT_BYREF | HB_IT_EXTREF;
pRefer->item.asExtRef.value = ( void * ) pMsgRef;
pRefer->item.asExtRef.func = &s_MsgExtRef;
return TRUE;
}
/* ------------------------------- */
/*
* extended object index reference structure
*/
typedef struct
{
HB_ITEM object;
HB_ITEM value;
HB_ITEM index;
} HB_MSGIDXREF, * PHB_MSGIDXREF;
| hvm.c | 6894 |
STATIC PHB_ITEM | hb_vmMsgIdxRefRead( PHB_ITEM pRefer )
static PHB_ITEM hb_vmMsgIdxRefRead( PHB_ITEM pRefer )
{
PHB_MSGIDXREF pMsgIdxRef = ( PHB_MSGIDXREF ) pRefer->item.asExtRef.value;
if( hb_vmRequestQuery() == 0 )
{
hb_stackPushReturn();
hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, &pMsgIdxRef->value,
HB_IS_BYREF( &pMsgIdxRef->object ) ?
hb_itemUnRef( &pMsgIdxRef->object ) :
&pMsgIdxRef->object, &pMsgIdxRef->index, NULL );
hb_stackPopReturn();
pMsgIdxRef->value.type |= HB_IT_DEFAULT;
}
return &pMsgIdxRef->value;
}
| hvm.c | 6938 |
STATIC PHB_ITEM | hb_vmMsgIdxRefWrite( PHB_ITEM pRefer, PHB_ITEM pSource )
static PHB_ITEM hb_vmMsgIdxRefWrite( PHB_ITEM pRefer, PHB_ITEM pSource )
{
PHB_MSGIDXREF pMsgIdxRef = ( PHB_MSGIDXREF ) pRefer->item.asExtRef.value;
if( hb_vmRequestQuery() == 0 )
{
PHB_ITEM pObject = HB_IS_BYREF( &pMsgIdxRef->object ) ?
hb_itemUnRef( &pMsgIdxRef->object ) :
&pMsgIdxRef->object;
hb_stackPushReturn();
hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pObject, pObject,
&pMsgIdxRef->index, pSource );
hb_stackPopReturn();
pMsgIdxRef->value.type |= HB_IT_DEFAULT;
}
return NULL; /*&pMsgIdxRef->value;*/
}
| hvm.c | 6958 |
STATIC VOID | hb_vmMsgIdxRefCopy( PHB_ITEM pDest )
static void hb_vmMsgIdxRefCopy( PHB_ITEM pDest )
{
hb_xRefInc( pDest->item.asExtRef.value );
}
| hvm.c | 6977 |
STATIC VOID | hb_vmMsgIdxRefClear( void * value )
static void hb_vmMsgIdxRefClear( void * value )
{
if( hb_xRefDec( value ) )
{
PHB_MSGIDXREF pMsgIdxRef = ( PHB_MSGIDXREF ) value;
/* value were change by C code without calling RefWrite(),
* f.e. hb_stor*() function
*/
if( ( pMsgIdxRef->value.type & HB_IT_DEFAULT ) == 0 )
{
if( hb_vmRequestReenter() )
{
PHB_ITEM pObject = HB_IS_BYREF( &pMsgIdxRef->object ) ?
hb_itemUnRef( &pMsgIdxRef->object ) :
&pMsgIdxRef->object;
hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pObject, pObject,
&pMsgIdxRef->index, &pMsgIdxRef->value );
hb_vmRequestRestore();
}
}
if( HB_IS_COMPLEX( &pMsgIdxRef->value ) )
hb_itemClear( &pMsgIdxRef->value );
if( HB_IS_COMPLEX( &pMsgIdxRef->object ) )
hb_itemClear( &pMsgIdxRef->object );
if( HB_IS_COMPLEX( &pMsgIdxRef->index ) )
hb_itemClear( &pMsgIdxRef->index );
hb_xfree( value );
}
}
| hvm.c | 6982 |
STATIC VOID | hb_vmMsgIdxRefMark( void * value )
static void hb_vmMsgIdxRefMark( void * value )
{
if( HB_IS_GCITEM( &( ( PHB_MSGIDXREF ) value )->object ) )
hb_gcItemRef( &( ( PHB_MSGIDXREF ) value )->object );
if( HB_IS_GCITEM( &( ( PHB_MSGIDXREF ) value )->index ) )
hb_gcItemRef( &( ( PHB_MSGIDXREF ) value )->index );
if( HB_IS_GCITEM( &( ( PHB_MSGIDXREF ) value )->value ) )
hb_gcItemRef( &( ( PHB_MSGIDXREF ) value )->value );
}
| hvm.c | 7012 |
STATIC VOID | hb_vmMsgIndexReference( PHB_ITEM pRefer, PHB_ITEM pObject, PHB_ITEM pIndex )
static void hb_vmMsgIndexReference( PHB_ITEM pRefer, PHB_ITEM pObject, PHB_ITEM pIndex )
{
static const HB_EXTREF s_MsgIdxExtRef = {
hb_vmMsgIdxRefRead,
hb_vmMsgIdxRefWrite,
hb_vmMsgIdxRefCopy,
hb_vmMsgIdxRefClear,
hb_vmMsgIdxRefMark };
PHB_MSGIDXREF pMsgIdxRef;
HB_TRACE(HB_TR_DEBUG, ("hb_vmMsgIndexReference(%p,%p,%p)", pRefer, pObject, pIndex));
pMsgIdxRef = ( PHB_MSGIDXREF ) hb_xgrab( sizeof( HB_MSGIDXREF ) );
pMsgIdxRef->value.type = HB_IT_NIL | HB_IT_DEFAULT;
pMsgIdxRef->object.type = HB_IT_NIL;
pMsgIdxRef->index.type = HB_IT_NIL;
hb_itemCopy( &pMsgIdxRef->object, HB_IS_STRING( pObject ) ? pRefer : pObject );
hb_itemCopy( &pMsgIdxRef->index, pIndex );
pIndex->type = HB_IT_BYREF | HB_IT_EXTREF;
pIndex->item.asExtRef.value = ( void * ) pMsgIdxRef;
pIndex->item.asExtRef.func = &s_MsgIdxExtRef;
hb_itemMove( pRefer, pIndex );
}
/* ------------------------------- */
/* VM exceptions */
| hvm.c | 7022 |
VOID | hb_vmRequestQuit( void )
void hb_vmRequestQuit( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmRequestQuit()"));
hb_vmDoExitFunctions(); /* process defined EXIT functions */
hb_stackSetActionRequest( HB_QUIT_REQUESTED );
}
| hvm.c | 7055 |
VOID | hb_vmRequestEndProc( void )
void hb_vmRequestEndProc( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmRequestEndProc()"));
hb_stackSetActionRequest( HB_ENDPROC_REQUESTED );
}
| hvm.c | 7063 |
VOID | hb_vmRequestBreak( PHB_ITEM pItem )
void hb_vmRequestBreak( PHB_ITEM pItem )
{
ULONG ulRecoverBase;
HB_TRACE(HB_TR_DEBUG, ("hb_vmRequestBreak(%p)", pItem));
ulRecoverBase = hb_stackGetRecoverBase();
while( ulRecoverBase && ( hb_stackItem( ulRecoverBase +
HB_RECOVER_STATE )->item.asRecover.flags & HB_SEQ_DOALWAYS ) )
{
ulRecoverBase = hb_stackItem( ulRecoverBase +
HB_RECOVER_STATE )->item.asRecover.base;
}
if( ulRecoverBase )
{
if( pItem )
hb_itemCopy( hb_stackItem( ulRecoverBase + HB_RECOVER_VALUE ), pItem );
hb_stackSetActionRequest( HB_BREAK_REQUESTED );
}
else
{
#ifdef HB_C52_STRICT
/*
* do not execute EXIT procedures to be as close as possible
* buggy Clipper behavior. [druzus]
*/
s_fDoExitProc = FALSE;
hb_stackSetActionRequest( HB_QUIT_REQUESTED );
#else
/*
* Clipper has a bug here. Tests shows that it set exception flag
* and then tries to execute EXIT procedures so the first one is
* immediately interrupted. Because Clipper does not check the
* exception flag often enough then it's possible to execute one
* function from first EXIT PROC. Using small trick with
* QOUT( TYPE( cPrivateVar ) ) in the EXIT procedure (TYPE() is
* not normal function) we can also check that it tries to execute
* EXIT procedures exactly here before leave current function.
* So to be as close as possible the Clipper intentional behavior
* we execute hb_vmRequestQuit() here. [druzus]
*/
hb_vmRequestQuit();
#endif
}
}
| hvm.c | 7070 |
VOID | hb_vmRequestCancel( void )
void hb_vmRequestCancel( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmRequestCancel()"));
if( hb_set.HB_SET_CANCEL )
{
char buffer[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5 + 10 ]; /* additional 10 bytes for line info (%hu) overhead */
USHORT uiLine;
int iLevel = 0, l;
hb_conOutErr( hb_conNewLine(), 0 );
hb_conOutErr( "Cancelled at: ", 0 );
while( hb_procinfo( iLevel++, buffer, &uiLine, NULL ) )
{
l = strlen( buffer );
snprintf( buffer + l, sizeof( buffer ) - l, " (%hu)", uiLine );
hb_conOutErr( buffer, 0 );
hb_conOutErr( hb_conNewLine(), 0 );
}
/*
* Clipper does not execute EXIT procedures when quiting using break key
*/
s_fDoExitProc = FALSE;
hb_stackSetActionRequest( HB_QUIT_REQUESTED );
}
}
| hvm.c | 7118 |
USHORT | hb_vmRequestQuery( void )
USHORT hb_vmRequestQuery( void )
{
return hb_stackGetActionRequest();
}
| hvm.c | 7148 |
BOOL | hb_vmRequestReenter( void )
BOOL hb_vmRequestReenter( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmRequestReenter()"));
if( !s_fHVMActive )
return FALSE;
hb_stackPushReturn();
hb_vmPushInteger( hb_stackGetActionRequest() );
hb_stackSetActionRequest( 0 );
return TRUE;
}
| hvm.c | 7153 |
VOID | hb_vmRequestRestore( void )
void hb_vmRequestRestore( void )
{
USHORT uiAction;
HB_TRACE(HB_TR_DEBUG, ("hb_vmRequestRestore()"));
uiAction = ( USHORT ) hb_stackItemFromTop( -1 )->item.asInteger.value |
hb_stackGetActionRequest();
if( uiAction & HB_QUIT_REQUESTED )
hb_stackSetActionRequest( HB_QUIT_REQUESTED );
else if( uiAction & HB_BREAK_REQUESTED )
hb_stackSetActionRequest( HB_BREAK_REQUESTED );
else if( uiAction & HB_ENDPROC_REQUESTED )
hb_stackSetActionRequest( HB_ENDPROC_REQUESTED );
else
hb_stackSetActionRequest( 0 );
hb_stackDec();
hb_stackPopReturn();
}
#define HB_XVM_RETURN return ( hb_stackGetActionRequest() & \
( HB_ENDPROC_REQUESTED | HB_BREAK_REQUESTED | HB_QUIT_REQUESTED ) ) != 0;
| hvm.c | 7168 |
HB_EXPORT VOID | hb_xvmExitProc( void )
HB_EXPORT void hb_xvmExitProc( void )
{
if( hb_stackGetActionRequest() & HB_ENDPROC_REQUESTED )
hb_stackSetActionRequest( 0 );
}
| hvm.c | 7195 |
HB_EXPORT VOID | hb_xvmEndProc( void )
HB_EXPORT void hb_xvmEndProc( void )
{
if( !( hb_stackGetActionRequest() & ( HB_QUIT_REQUESTED | HB_BREAK_REQUESTED ) ) )
hb_stackSetActionRequest( HB_ENDPROC_REQUESTED );
}
| hvm.c | 7201 |
HB_EXPORT VOID | hb_xvmSeqBegin( void )
HB_EXPORT void hb_xvmSeqBegin( void )
{
PHB_ITEM pItem;
/*
* Create the SEQUENCE envelope
* To keep compatibility with pure PCODE evaluation we have
* use exactly the same SEQUENCE envelope or hb_vmRequestBreak()
* will not work as expected.
*
* [ break return value ] -2
* [ recover envelope ] -1
* [ ] <- new recover base
*/
/* 1) clear the storage for value returned by BREAK statement */
hb_stackAllocItem()->type = HB_IT_NIL;
/* 2) recovery state */
pItem = hb_stackAllocItem();
/* mark type as NIL - it's not real item */
pItem->type = HB_IT_NIL;
/* address of RECOVER or END opcode - not used in C code */
pItem->item.asRecover.recover = 0;
/* store current RECOVER base */
pItem->item.asRecover.base = hb_stackGetRecoverBase();
/* store current bCanRecover flag - not used in C code */
pItem->item.asRecover.flags = 0;
/* clear new recovery state */
pItem->item.asRecover.request = 0;
/* set new recover base */
hb_stackSetRecoverBase( hb_stackTopOffset() );
}
| hvm.c | 7207 |
HB_EXPORT BOOL | hb_xvmSeqEnd( void )
HB_EXPORT BOOL hb_xvmSeqEnd( void )
{
/*
* remove all items placed on the stack after BEGIN code
*/
hb_stackRemove( hb_stackGetRecoverBase() );
/*
* Remove the SEQUENCE envelope
* This is executed either at the end of sequence or as the
* response to the break statement if there is no RECOVER clause
*/
/* 2) Restore previous recovery base address */
hb_stackSetRecoverBase( hb_stackItemFromTop( -1 )->item.asRecover.base );
hb_stackDec();
/* 1) Discard the value returned by BREAK statement */
hb_stackPop();
if( hb_stackGetActionRequest() & ( HB_ENDPROC_REQUESTED | HB_QUIT_REQUESTED ) )
return TRUE;
else if( hb_stackGetActionRequest() & HB_BREAK_REQUESTED )
hb_stackSetActionRequest( 0 );
return FALSE;
}
| hvm.c | 7240 |
HB_EXPORT BOOL | hb_xvmSeqEndTest( void )
HB_EXPORT BOOL hb_xvmSeqEndTest( void )
{
if( ( hb_stackGetActionRequest() &
( HB_ENDPROC_REQUESTED | HB_BREAK_REQUESTED | HB_QUIT_REQUESTED ) ) != 0 )
return TRUE;
/*
* remove all items placed on the stack after BEGIN code
*/
hb_stackRemove( hb_stackGetRecoverBase() );
/*
* Remove the SEQUENCE envelope
* This is executed either at the end of sequence or as the
* response to the break statement if there is no RECOVER clause
*/
/* 2) Restore previous recovery base address */
hb_stackSetRecoverBase( hb_stackItemFromTop( -1 )->item.asRecover.base );
hb_stackDec();
/* 1) Discard the value returned by BREAK statement */
hb_stackPop();
return FALSE;
}
| hvm.c | 7266 |
HB_EXPORT BOOL | hb_xvmSeqRecover( void )
HB_EXPORT BOOL hb_xvmSeqRecover( void )
{
/*
* Execute the RECOVER code
*/
/*
* remove all items placed on the stack after BEGIN code
*/
hb_stackRemove( hb_stackGetRecoverBase() );
/* 2) Restore previous recovery base address */
hb_stackSetRecoverBase( hb_stackItemFromTop( -1 )->item.asRecover.base );
hb_stackDec();
/* 1) Leave the value returned from BREAK */
if( hb_stackGetActionRequest() & ( HB_ENDPROC_REQUESTED | HB_QUIT_REQUESTED ) )
return TRUE;
else if( hb_stackGetActionRequest() & HB_BREAK_REQUESTED )
hb_stackSetActionRequest( 0 );
return FALSE;
}
| hvm.c | 7291 |
HB_EXPORT VOID | hb_xvmSeqAlways( void )
HB_EXPORT void hb_xvmSeqAlways( void )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmSeqAlways()"));
/* Create the SEQUENCE ALWAYS envelope */
/* 1) clear the storage for RETURN value */
hb_stackAllocItem()->type = HB_IT_NIL;
/* 2) recovery state */
pItem = hb_stackAllocItem();
/* mark type as NIL - it's not real item */
pItem->type = HB_IT_NIL;
/* address of RECOVER or END opcode - not used in C code */
pItem->item.asRecover.recover = 0;
/* store current RECOVER base */
pItem->item.asRecover.base = hb_stackGetRecoverBase();
/* store current bCanRecover flag - not used in C code */
pItem->item.asRecover.flags = 0;
/* clear new recovery state */
pItem->item.asRecover.request = 0;
/* set sequence type */
pItem->item.asRecover.flags = HB_SEQ_DOALWAYS;
/* set new recover base */
hb_stackSetRecoverBase( hb_stackTopOffset() );
}
| hvm.c | 7314 |
HB_EXPORT BOOL | hb_xvmAlwaysBegin( void )
HB_EXPORT BOOL hb_xvmAlwaysBegin( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmAlwaysBegin()"));
/* remove all items placed on the stack after BEGIN code */
hb_stackRemove( hb_stackGetRecoverBase() );
/* store and reset action */
hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.request = hb_stackGetActionRequest();
hb_stackSetActionRequest( 0 );
/* store RETURN value */
if( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.request & HB_ENDPROC_REQUESTED )
hb_itemMove( hb_stackItemFromTop( HB_RECOVER_VALUE ), hb_stackReturnItem() );
HB_XVM_RETURN
}
| hvm.c | 7341 |
HB_EXPORT BOOL | hb_xvmAlwaysEnd( void )
HB_EXPORT BOOL hb_xvmAlwaysEnd( void )
{
USHORT uiPrevAction, uiCurrAction;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmAlwaysEnd()"));
/* remove all items placed on the stack after ALWAYSBEGIN code */
hb_stackRemove( hb_stackGetRecoverBase() );
/* restore previous recovery base address */
hb_stackSetRecoverBase( hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.base );
uiCurrAction = hb_stackGetActionRequest();
uiPrevAction = hb_stackItemFromTop( HB_RECOVER_STATE )->item.asRecover.request;
/* restore requested action */
if( ( uiCurrAction | uiPrevAction ) & HB_QUIT_REQUESTED )
hb_stackSetActionRequest( HB_QUIT_REQUESTED );
else if( ( uiCurrAction | uiPrevAction ) & HB_BREAK_REQUESTED )
hb_stackSetActionRequest( HB_BREAK_REQUESTED );
else if( ( uiCurrAction | uiPrevAction ) & HB_ENDPROC_REQUESTED )
hb_stackSetActionRequest( HB_ENDPROC_REQUESTED );
else
hb_stackSetActionRequest( 0 );
/* remove the ALWAYS envelope */
hb_stackDec();
/* restore RETURN value if not overloaded inside ALWAYS code */
if( !( uiCurrAction & HB_ENDPROC_REQUESTED ) &&
( uiPrevAction & HB_ENDPROC_REQUESTED ) )
hb_stackPopReturn();
else
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 7357 |
HB_EXPORT BOOL | hb_xvmSeqBlock( void )
HB_EXPORT BOOL hb_xvmSeqBlock( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmSeqBlock()"));
hb_vmSeqBlock();
HB_XVM_RETURN
}
| hvm.c | 7390 |
HB_EXPORT BOOL | hb_xvmEnumStart( BYTE nVars, BYTE nDescend )
HB_EXPORT BOOL hb_xvmEnumStart( BYTE nVars, BYTE nDescend )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmEnumStart(%d,%d)", nVars, nDescend));
hb_vmEnumStart( nVars, nDescend );
HB_XVM_RETURN
}
| hvm.c | 7399 |
HB_EXPORT BOOL | hb_xvmEnumNext( void )
HB_EXPORT BOOL hb_xvmEnumNext( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmEnumNext()"));
hb_vmEnumNext();
HB_XVM_RETURN
}
| hvm.c | 7408 |
HB_EXPORT BOOL | hb_xvmEnumPrev( void )
HB_EXPORT BOOL hb_xvmEnumPrev( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmEnumPrev()"));
hb_vmEnumPrev();
HB_XVM_RETURN
}
| hvm.c | 7417 |
HB_EXPORT VOID | hb_xvmEnumEnd( void )
HB_EXPORT void hb_xvmEnumEnd( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmEnumEnd()"));
hb_vmEnumEnd();
}
| hvm.c | 7426 |
HB_EXPORT VOID | hb_xvmSetLine( USHORT uiLine )
HB_EXPORT void hb_xvmSetLine( USHORT uiLine )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmSetLine(%hu)", uiLine));
hb_stackBaseItem()->item.asSymbol.stackstate->uiLineNo = uiLine;
#ifndef HB_NO_DEBUG
if( s_bDebugging )
hb_vmDebuggerShowLine( uiLine );
#endif
}
| hvm.c | 7433 |
HB_EXPORT VOID | hb_xvmFrame( int iLocals, int iParams )
HB_EXPORT void hb_xvmFrame( int iLocals, int iParams )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmFrame(%d, %d)", iLocals, iParams));
hb_vmFrame( ( USHORT ) iLocals, ( BYTE ) iParams );
}
| hvm.c | 7444 |
HB_EXPORT VOID | hb_xvmVFrame( int iLocals, int iParams )
HB_EXPORT void hb_xvmVFrame( int iLocals, int iParams )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmVFrame(%d, %d)", iLocals, iParams));
hb_vmVFrame( ( USHORT ) iLocals, ( BYTE ) iParams );
}
| hvm.c | 7451 |
HB_EXPORT VOID | hb_xvmSFrame( PHB_SYMB pSymbol )
HB_EXPORT void hb_xvmSFrame( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmSFrame(%p)", pSymbol));
hb_vmSFrame( pSymbol );
}
| hvm.c | 7458 |
HB_EXPORT BOOL | hb_xvmDo( USHORT uiParams )
HB_EXPORT BOOL hb_xvmDo( USHORT uiParams )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmDo(%hu)", uiParams));
hb_vmDo( uiParams );
HB_XVM_RETURN
}
| hvm.c | 7465 |
HB_EXPORT BOOL | hb_xvmFunction( USHORT uiParams )
HB_EXPORT BOOL hb_xvmFunction( USHORT uiParams )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmFunction(%hu)", uiParams));
hb_itemSetNil( hb_stackReturnItem() );
hb_vmDo( uiParams );
hb_stackPushReturn();
HB_XVM_RETURN
}
| hvm.c | 7474 |
HB_EXPORT BOOL | hb_xvmSend( USHORT uiParams )
HB_EXPORT BOOL hb_xvmSend( USHORT uiParams )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmSend(%hu)", uiParams));
hb_itemSetNil( hb_stackReturnItem() );
hb_vmSend( uiParams );
hb_stackPushReturn();
HB_XVM_RETURN
}
| hvm.c | 7485 |
HB_EXPORT BOOL | hb_xvmPushObjectVarRef( void )
HB_EXPORT BOOL hb_xvmPushObjectVarRef( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushObjectVarRef()"));
hb_vmPushObjectVarRef();
HB_XVM_RETURN
}
| hvm.c | 7496 |
HB_EXPORT VOID | hb_xvmRetValue( void )
HB_EXPORT void hb_xvmRetValue( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmRetValue()"));
hb_stackPopReturn();
hb_stackReturnItem()->type &= ~HB_IT_MEMOFLAG;
}
| hvm.c | 7505 |
HB_EXPORT VOID | hb_xvmStatics( PHB_SYMB pSymbol, USHORT uiStatics )
HB_EXPORT void hb_xvmStatics( PHB_SYMB pSymbol, USHORT uiStatics )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmStatics(%p,%hu)", pSymbol, uiStatics));
hb_vmStatics( pSymbol, uiStatics );
}
| hvm.c | 7513 |
HB_EXPORT VOID | hb_xvmParameter( PHB_SYMB pSymbol, int iParams )
HB_EXPORT void hb_xvmParameter( PHB_SYMB pSymbol, int iParams )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmParameter(%p,%d)", pSymbol, iParams));
hb_memvarNewParameter( pSymbol, hb_stackItemFromBase( iParams ) );
}
| hvm.c | 7520 |
HB_EXPORT VOID | hb_xvmPushLocal( SHORT iLocal )
HB_EXPORT void hb_xvmPushLocal( SHORT iLocal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushLocal(%hd)", iLocal));
hb_vmPushLocal( iLocal );
}
| hvm.c | 7527 |
HB_EXPORT VOID | hb_xvmPushLocalByRef( SHORT iLocal )
HB_EXPORT void hb_xvmPushLocalByRef( SHORT iLocal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushLocalByRef(%hd)", iLocal));
hb_vmPushLocalByRef( iLocal );
}
| hvm.c | 7534 |
HB_EXPORT VOID | hb_xvmPopLocal( SHORT iLocal )
HB_EXPORT void hb_xvmPopLocal( SHORT iLocal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPopLocal(%hd)", iLocal));
hb_vmPopLocal( iLocal );
}
| hvm.c | 7541 |
HB_EXPORT PHB_ITEM | hb_xvmLocalPtr( int iLocal )
HB_EXPORT PHB_ITEM hb_xvmLocalPtr( int iLocal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLocalPtr(%d)", iLocal));
if( iLocal >= 0 )
{
/* local variable or local parameter */
return hb_stackLocalVariable( &iLocal );
}
else
{
/* local variable referenced in a codeblock
* hb_stackSelfItem() points to a codeblock that is currently evaluated
*/
return hb_codeblockGetRef( hb_stackSelfItem()->item.asBlock.value, ( LONG ) iLocal );
}
}
| hvm.c | 7548 |
HB_EXPORT PHB_ITEM | hb_xvmStaticPtr( int iStatic )
HB_EXPORT PHB_ITEM hb_xvmStaticPtr( int iStatic )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmStaticPtr(%d)", iStatic));
return s_aStatics.item.asArray.value->pItems + hb_stackGetStaticsBase() + iStatic - 1;
}
| hvm.c | 7566 |
HB_EXPORT VOID | hb_xvmCopyLocals( int iDest, int iSource )
HB_EXPORT void hb_xvmCopyLocals( int iDest, int iSource )
{
PHB_ITEM pDest;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmCopyLocals(%d,%d)", iDest, iSource));
pDest = hb_xvmLocalPtr( iDest );
hb_itemCopyToRef( hb_xvmLocalPtr( iSource ),
HB_IS_BYREF( pDest ) ? hb_itemUnRef( pDest ) : pDest );
}
| hvm.c | 7573 |
HB_EXPORT VOID | hb_xvmPushStatic( USHORT uiStatic )
HB_EXPORT void hb_xvmPushStatic( USHORT uiStatic )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushStatic(%hu)", uiStatic));
hb_vmPushStatic( uiStatic );
}
| hvm.c | 7584 |
HB_EXPORT VOID | hb_xvmPushStaticByRef( USHORT uiStatic )
HB_EXPORT void hb_xvmPushStaticByRef( USHORT uiStatic )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushStaticByRef(%hu)", uiStatic));
hb_vmPushStaticByRef( uiStatic );
}
| hvm.c | 7591 |
HB_EXPORT VOID | hb_xvmPopStatic( USHORT uiStatic )
HB_EXPORT void hb_xvmPopStatic( USHORT uiStatic )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPopStatic(%hu)", uiStatic));
hb_vmPopStatic( uiStatic );
}
| hvm.c | 7598 |
HB_EXPORT BOOL | hb_xvmPushVariable( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmPushVariable( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_INFO, ("hb_xvmPushVariable(%p)", pSymbol));
hb_vmPushVariable( pSymbol );
HB_XVM_RETURN
}
| hvm.c | 7605 |
HB_EXPORT BOOL | hb_xvmPopVariable( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmPopVariable( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_INFO, ("hb_xvmPopVariable(%p)", pSymbol));
/* See the note above in HB_P_POPVARIABLE */
#if 0
if( pSymbol->pDynSym && pSymbol->pDynSym->hMemvar )
hb_memvarSetValue( pSymbol, hb_stackItemFromTop(-1) );
else if( hb_rddFieldPut( hb_stackItemFromTop(-1), pSymbol ) == FAILURE )
#endif
hb_memvarSetValue( pSymbol, hb_stackItemFromTop(-1) );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 7614 |
HB_EXPORT VOID | hb_xvmPushBlockShort( const BYTE * pCode, PHB_SYMB pSymbols )
HB_EXPORT void hb_xvmPushBlockShort( const BYTE * pCode, PHB_SYMB pSymbols )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushBlockShort(%p, %p)", pCode, pSymbols));
hb_vmPushBlockShort( pCode, pSymbols, FALSE );
}
| hvm.c | 7630 |
HB_EXPORT VOID | hb_xvmPushBlock( const BYTE * pCode, PHB_SYMB pSymbols )
HB_EXPORT void hb_xvmPushBlock( const BYTE * pCode, PHB_SYMB pSymbols )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushBlock(%p, %p)", pCode, pSymbols));
hb_vmPushBlock( pCode, pSymbols, FALSE );
}
| hvm.c | 7637 |
HB_EXPORT VOID | hb_xvmPushSelf( void )
HB_EXPORT void hb_xvmPushSelf( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushSelf()"));
hb_vmPush( hb_stackSelfItem() );
}
| hvm.c | 7644 |
HB_EXPORT VOID | hb_xvmPushFuncSymbol( PHB_SYMB pSym )
HB_EXPORT void hb_xvmPushFuncSymbol( PHB_SYMB pSym )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushFuncSymbol(%p)", pSym));
pItem = hb_stackAllocItem();
pItem->type = HB_IT_SYMBOL;
pItem->item.asSymbol.value = pSym;
pItem->item.asSymbol.stackstate = NULL;
hb_stackAllocItem()->type = HB_IT_NIL;
}
| hvm.c | 7651 |
HB_EXPORT BOOL | hb_xvmPopLogical( BOOL * pfValue )
HB_EXPORT BOOL hb_xvmPopLogical( BOOL * pfValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPopLogical(%p)", pfValue));
*pfValue = hb_vmPopLogical();
HB_XVM_RETURN
}
| hvm.c | 7664 |
HB_EXPORT BOOL | hb_xvmPopAlias( void )
HB_EXPORT BOOL hb_xvmPopAlias( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPopAlias()"));
hb_vmSelectWorkarea( hb_stackItemFromTop( -1 ), NULL ); /* it clears the passed item */
hb_stackDec();
HB_XVM_RETURN
}
| hvm.c | 7673 |
HB_EXPORT BOOL | hb_xvmSwapAlias( void )
HB_EXPORT BOOL hb_xvmSwapAlias( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmSwapAlias()"));
hb_vmSwapAlias();
HB_XVM_RETURN
}
| hvm.c | 7683 |
HB_EXPORT BOOL | hb_xvmPushField( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmPushField( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_INFO, ("hb_xvmPushField(%p)", pSymbol));
hb_rddGetFieldValue( hb_stackAllocItem(), pSymbol );
HB_XVM_RETURN
}
| hvm.c | 7692 |
HB_EXPORT BOOL | hb_xvmPushAlias( void )
HB_EXPORT BOOL hb_xvmPushAlias( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushAlias()"));
hb_vmPushAlias();
HB_XVM_RETURN
}
| hvm.c | 7701 |
HB_EXPORT BOOL | hb_xvmPushAliasedField( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmPushAliasedField( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_INFO, ("hb_xvmPushAliasedField(%p)", pSymbol));
hb_vmPushAliasedField( pSymbol );
HB_XVM_RETURN
}
| hvm.c | 7710 |
HB_EXPORT BOOL | hb_xvmPushAliasedVar( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmPushAliasedVar( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_INFO, ("hb_xvmPushAliasedVar(%p)", pSymbol));
hb_vmPushAliasedVar( pSymbol );
HB_XVM_RETURN
}
| hvm.c | 7719 |
HB_EXPORT BOOL | hb_xvmPopField( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmPopField( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_INFO, ("hb_xvmPopField(%p)", pSymbol));
hb_rddPutFieldValue( hb_stackItemFromTop(-1), pSymbol );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 7728 |
HB_EXPORT BOOL | hb_xvmPushMemvar( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmPushMemvar( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_INFO, ("hb_xvmPushMemvar(%p)", pSymbol));
hb_memvarGetValue( hb_stackAllocItem(), pSymbol );
HB_XVM_RETURN
}
| hvm.c | 7737 |
HB_EXPORT BOOL | hb_xvmPushMemvarByRef( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmPushMemvarByRef( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_INFO, ("hb_xvmPushMemvarByRef(%p)", pSymbol));
hb_memvarGetRefer( hb_stackAllocItem(), pSymbol );
HB_XVM_RETURN
}
| hvm.c | 7746 |
HB_EXPORT BOOL | hb_xvmPopMemvar( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmPopMemvar( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_INFO, ("hb_xvmPopMemvar(%p)", pSymbol));
hb_memvarSetValue( pSymbol, hb_stackItemFromTop(-1) );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 7755 |
HB_EXPORT BOOL | hb_xvmPopAliasedField( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmPopAliasedField( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_INFO, ("hb_xvmPopAliasedField(%p)", pSymbol));
hb_vmPopAliasedField( pSymbol );
HB_XVM_RETURN
}
| hvm.c | 7765 |
HB_EXPORT BOOL | hb_xvmPopAliasedVar( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmPopAliasedVar( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_INFO, ("hb_xvmPopAliasedVar(%p)", pSymbol));
hb_vmPopAliasedVar( pSymbol );
HB_XVM_RETURN
}
| hvm.c | 7774 |
HB_EXPORT VOID | hb_xvmLocalSetInt( int iLocal, LONG lValue )
HB_EXPORT void hb_xvmLocalSetInt( int iLocal, LONG lValue )
{
PHB_ITEM pLocal;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLocalSetInt(%d, %d)", iLocal, lValue));
if( iLocal >= 0 )
{
/* local variable or local parameter */
pLocal = hb_stackLocalVariable( &iLocal );
if( HB_IS_BYREF( pLocal ) )
pLocal = hb_itemUnRef( pLocal );
}
else
{
/* local variable referenced in a codeblock
* hb_stackSelfItem() points to a codeblock that is currently evaluated
*/
pLocal = hb_codeblockGetVar( hb_stackSelfItem(), iLocal );
}
if( HB_IS_OBJECT( pLocal ) && hb_objHasOperator( pLocal, HB_OO_OP_ASSIGN ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_ASSIGN, pLocal, pLocal,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
}
else
{
hb_itemPutNL( pLocal, lValue );
}
}
| hvm.c | 7783 |
HB_EXPORT BOOL | hb_xvmLocalAddInt( int iLocal, LONG lAdd )
HB_EXPORT BOOL hb_xvmLocalAddInt( int iLocal, LONG lAdd )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLocalAddInt(%d,%ld)", iLocal, lAdd));
hb_vmAddInt( hb_stackLocalVariable( &iLocal ), lAdd );
HB_XVM_RETURN
}
| hvm.c | 7817 |
HB_EXPORT BOOL | hb_xvmLocalInc( int iLocal )
HB_EXPORT BOOL hb_xvmLocalInc( int iLocal )
{
PHB_ITEM pLocal;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLocalInc(%d)", iLocal));
pLocal = hb_stackLocalVariable( &iLocal );
hb_vmInc( HB_IS_BYREF( pLocal ) ? hb_itemUnRef( pLocal ) : pLocal );
HB_XVM_RETURN
}
| hvm.c | 7826 |
HB_EXPORT BOOL | hb_xvmLocalDec( int iLocal )
HB_EXPORT BOOL hb_xvmLocalDec( int iLocal )
{
PHB_ITEM pLocal;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLocalDec(%d)", iLocal));
pLocal = hb_stackLocalVariable( &iLocal );
hb_vmDec( HB_IS_BYREF( pLocal ) ? hb_itemUnRef( pLocal ) : pLocal );
HB_XVM_RETURN
}
| hvm.c | 7838 |
HB_EXPORT BOOL | hb_xvmLocalIncPush( int iLocal )
HB_EXPORT BOOL hb_xvmLocalIncPush( int iLocal )
{
PHB_ITEM pLocal;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLocalInc(%d)", iLocal));
pLocal = hb_stackLocalVariable( &iLocal );
if( HB_IS_BYREF( pLocal ) )
pLocal = hb_itemUnRef( pLocal );
hb_vmInc( pLocal );
hb_itemCopy( hb_stackAllocItem(), pLocal );
HB_XVM_RETURN
}
| hvm.c | 7850 |
HB_EXPORT BOOL | hb_xvmLocalAdd( int iLocal )
HB_EXPORT BOOL hb_xvmLocalAdd( int iLocal )
{
PHB_ITEM pLocal;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLocalAdd(%d)", iLocal));
pLocal = hb_stackLocalVariable( &iLocal );
if( HB_IS_BYREF( pLocal ) )
pLocal = hb_itemUnRef( pLocal );
hb_vmPlus( pLocal, hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 7865 |
HB_EXPORT BOOL | hb_xvmStaticAdd( USHORT uiStatic )
HB_EXPORT BOOL hb_xvmStaticAdd( USHORT uiStatic )
{
PHB_ITEM pStatic;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmStaticAdd(%hu)", uiStatic));
pStatic = s_aStatics.item.asArray.value->pItems + hb_stackGetStaticsBase() + uiStatic - 1;
if( HB_IS_BYREF( pStatic ) )
pStatic = hb_itemUnRef( pStatic );
hb_vmPlus( pStatic, hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 7881 |
HB_EXPORT BOOL | hb_xvmMemvarAdd( PHB_SYMB pSymbol )
HB_EXPORT BOOL hb_xvmMemvarAdd( PHB_SYMB pSymbol )
{
PHB_ITEM pMemVar, pVal1, pVal2;
HB_TRACE(HB_TR_INFO, ("hb_xvmMemvarAdd(%p)", pSymbol));
pVal1 = hb_stackItemFromTop( -2 );
pVal2 = hb_stackItemFromTop( -1 );
if( HB_IS_STRING( pVal1 ) && HB_IS_STRING( pVal2 ) )
{
pMemVar = hb_memvarGetItem( pSymbol );
if( pMemVar )
{
hb_vmPlus( pMemVar, pVal1, pVal2 );
hb_stackPop();
hb_stackPop();
HB_XVM_RETURN
}
}
hb_vmPlus( pVal1, pVal1, pVal2 );
hb_memvarSetValue( pSymbol, pVal1 );
hb_stackPop();
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 7897 |
HB_EXPORT BOOL | hb_xvmAnd( void )
HB_EXPORT BOOL hb_xvmAnd( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmAnd()"));
hb_vmAnd();
HB_XVM_RETURN
}
| hvm.c | 7925 |
HB_EXPORT BOOL | hb_xvmOr( void )
HB_EXPORT BOOL hb_xvmOr( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmOr()"));
hb_vmOr();
HB_XVM_RETURN
}
| hvm.c | 7934 |
HB_EXPORT BOOL | hb_xvmNot( void )
HB_EXPORT BOOL hb_xvmNot( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmNot()"));
hb_vmNot();
HB_XVM_RETURN
}
| hvm.c | 7943 |
HB_EXPORT BOOL | hb_xvmNegate( void )
HB_EXPORT BOOL hb_xvmNegate( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmNegate()"));
hb_vmNegate();
HB_XVM_RETURN
}
| hvm.c | 7952 |
HB_EXPORT VOID | hb_xvmDuplicate( void )
HB_EXPORT void hb_xvmDuplicate( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmDuplicate()"));
hb_vmDuplicate();
}
| hvm.c | 7961 |
HB_EXPORT VOID | hb_xvmDuplUnRef( void )
HB_EXPORT void hb_xvmDuplUnRef( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmDuplUnRef()"));
hb_vmDuplUnRef();
}
| hvm.c | 7968 |
HB_EXPORT VOID | hb_xvmDuplTwo( void )
HB_EXPORT void hb_xvmDuplTwo( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmDuplTwo()"));
hb_vmDuplTwo();
}
| hvm.c | 7975 |
HB_EXPORT VOID | hb_xvmPushUnRef( void )
HB_EXPORT void hb_xvmPushUnRef( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushUnRef()"));
hb_vmPushUnRef();
}
| hvm.c | 7982 |
HB_EXPORT VOID | hb_xvmSwap( int iCount )
HB_EXPORT void hb_xvmSwap( int iCount )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmSwap(%d)", iCount));
hb_vmSwap( ( BYTE ) iCount );
}
| hvm.c | 7989 |
HB_EXPORT BOOL | hb_xvmForTest( void )
HB_EXPORT BOOL hb_xvmForTest( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmForTest()"));
hb_vmForTest();
HB_XVM_RETURN
}
| hvm.c | 7996 |
HB_EXPORT VOID | hb_xvmFuncPtr( void )
HB_EXPORT void hb_xvmFuncPtr( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmFuncPtr()"));
hb_vmFuncPtr();
}
| hvm.c | 8005 |
HB_EXPORT BOOL | hb_xvmEqual( void )
HB_EXPORT BOOL hb_xvmEqual( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmEqual()"));
hb_vmEqual();
HB_XVM_RETURN
}
| hvm.c | 8012 |
HB_EXPORT BOOL | hb_xvmExactlyEqual( void )
HB_EXPORT BOOL hb_xvmExactlyEqual( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmExactlyEqual()"));
hb_vmExactlyEqual();
HB_XVM_RETURN
}
| hvm.c | 8021 |
HB_EXPORT BOOL | hb_xvmEqualInt( LONG lValue )
HB_EXPORT BOOL hb_xvmEqualInt( LONG lValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmEqualInt(%ld)", lValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NIL( pItem ) )
{
pItem->type = HB_IT_LOGICAL;
pItem->item.asLogical.value = FALSE;
}
else if( HB_IS_NUMINT( pItem ) )
{
pItem->item.asLogical.value = HB_ITEM_GET_NUMINTRAW( pItem ) == ( HB_LONG ) lValue;
pItem->type = HB_IT_LOGICAL;
}
else if( HB_IS_NUMERIC( pItem ) )
{
double dNumber = hb_vmPopNumber();
hb_vmPushLogical( dNumber == ( double ) lValue );
}
else if( hb_objHasOperator( pItem, HB_OO_OP_EQUAL ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_EQUAL, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1071, NULL, "=", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
}
}
HB_XVM_RETURN
}
| hvm.c | 8030 |
HB_EXPORT BOOL | hb_xvmEqualIntIs( LONG lValue, BOOL * pfValue )
HB_EXPORT BOOL hb_xvmEqualIntIs( LONG lValue, BOOL * pfValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmEqualIntIs(%ld,%p)", lValue, pfValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NIL( pItem ) )
{
* pfValue = FALSE;
hb_stackDec();
}
else if( HB_IS_NUMINT( pItem ) )
{
* pfValue = HB_ITEM_GET_NUMINTRAW( pItem ) == ( HB_LONG ) lValue;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem ) )
{
* pfValue = hb_vmPopNumber() == ( double ) lValue;
}
else if( hb_objHasOperator( pItem, HB_OO_OP_EQUAL ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_EQUAL, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
return hb_xvmPopLogical( pfValue );
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1071, NULL, "=", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
return hb_xvmPopLogical( pfValue );
}
}
HB_XVM_RETURN
}
| hvm.c | 8077 |
HB_EXPORT BOOL | hb_xvmNotEqual( void )
HB_EXPORT BOOL hb_xvmNotEqual( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmNotEqual()"));
hb_vmNotEqual();
HB_XVM_RETURN
}
| hvm.c | 8125 |
HB_EXPORT BOOL | hb_xvmNotEqualInt( LONG lValue )
HB_EXPORT BOOL hb_xvmNotEqualInt( LONG lValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmNotEqualInt(%ld)", lValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NIL( pItem ) )
{
pItem->type = HB_IT_LOGICAL;
pItem->item.asLogical.value = TRUE;
}
else if( HB_IS_NUMINT( pItem ) )
{
pItem->item.asLogical.value = HB_ITEM_GET_NUMINTRAW( pItem ) != ( HB_LONG ) lValue;
pItem->type = HB_IT_LOGICAL;
}
else if( HB_IS_NUMERIC( pItem ) )
{
double dNumber = hb_vmPopNumber();
hb_vmPushLogical( dNumber != ( double ) lValue );
}
else if( hb_objHasOperator( pItem, HB_OO_OP_NOTEQUAL ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_NOTEQUAL, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1072, NULL, "<>", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
}
}
HB_XVM_RETURN
}
| hvm.c | 8134 |
HB_EXPORT BOOL | hb_xvmNotEqualIntIs( LONG lValue, BOOL * pfValue )
HB_EXPORT BOOL hb_xvmNotEqualIntIs( LONG lValue, BOOL * pfValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmNotEqualIntIs(%ld,%p)", lValue, pfValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NIL( pItem ) )
{
* pfValue = TRUE;
hb_stackDec();
}
else if( HB_IS_NUMINT( pItem ) )
{
* pfValue = HB_ITEM_GET_NUMINTRAW( pItem ) != ( HB_LONG ) lValue;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem ) )
{
* pfValue = hb_vmPopNumber() != ( double ) lValue;
}
else if( hb_objHasOperator( pItem, HB_OO_OP_NOTEQUAL ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_NOTEQUAL, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
return hb_xvmPopLogical( pfValue );
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1072, NULL, "<>", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
return hb_xvmPopLogical( pfValue );
}
}
HB_XVM_RETURN
}
| hvm.c | 8181 |
HB_EXPORT BOOL | hb_xvmLess( void )
HB_EXPORT BOOL hb_xvmLess( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLess()"));
hb_vmLess();
HB_XVM_RETURN
}
| hvm.c | 8229 |
HB_EXPORT BOOL | hb_xvmLessThenInt( LONG lValue )
HB_EXPORT BOOL hb_xvmLessThenInt( LONG lValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLessThenInt(%ld)", lValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NUMINT( pItem ) )
{
pItem->item.asLogical.value = HB_ITEM_GET_NUMINTRAW( pItem ) < ( HB_LONG ) lValue;
pItem->type = HB_IT_LOGICAL;
}
else if( HB_IS_NUMERIC( pItem ) )
{
hb_vmPushLogical( hb_vmPopNumber() < ( double ) lValue );
}
else if( hb_objHasOperator( pItem, HB_OO_OP_LESS ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_LESS, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1073, NULL, "<", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
}
}
HB_XVM_RETURN
}
| hvm.c | 8238 |
HB_EXPORT BOOL | hb_xvmLessThenIntIs( LONG lValue, BOOL * pfValue )
HB_EXPORT BOOL hb_xvmLessThenIntIs( LONG lValue, BOOL * pfValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLessThenIntIs(%ld,%p)", lValue, pfValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NUMINT( pItem ) )
{
* pfValue = HB_ITEM_GET_NUMINTRAW( pItem ) < ( HB_LONG ) lValue;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem ) )
{
* pfValue = hb_vmPopNumber() < ( double ) lValue;
}
else if( hb_objHasOperator( pItem, HB_OO_OP_LESS ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_LESS, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
return hb_xvmPopLogical( pfValue );
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1073, NULL, "<", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
return hb_xvmPopLogical( pfValue );
}
}
HB_XVM_RETURN
}
| hvm.c | 8279 |
HB_EXPORT BOOL | hb_xvmLessEqual( void )
HB_EXPORT BOOL hb_xvmLessEqual( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLessEqual()"));
hb_vmLessEqual();
HB_XVM_RETURN
}
| hvm.c | 8322 |
HB_EXPORT BOOL | hb_xvmLessEqualThenInt( LONG lValue )
HB_EXPORT BOOL hb_xvmLessEqualThenInt( LONG lValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLessEqualThenInt(%ld)", lValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NUMINT( pItem ) )
{
pItem->item.asLogical.value = HB_ITEM_GET_NUMINTRAW( pItem ) <= ( HB_LONG ) lValue;
pItem->type = HB_IT_LOGICAL;
}
else if( HB_IS_NUMERIC( pItem ) )
{
hb_vmPushLogical( hb_vmPopNumber() <= ( double ) lValue );
}
else if( hb_objHasOperator( pItem, HB_OO_OP_LESSEQUAL ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_LESSEQUAL, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1074, NULL, "<=", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
}
}
HB_XVM_RETURN
}
| hvm.c | 8331 |
HB_EXPORT BOOL | hb_xvmLessEqualThenIntIs( LONG lValue, BOOL * pfValue )
HB_EXPORT BOOL hb_xvmLessEqualThenIntIs( LONG lValue, BOOL * pfValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLessEqualThenIntIs(%ld,%p)", lValue, pfValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NUMINT( pItem ) )
{
* pfValue = HB_ITEM_GET_NUMINTRAW( pItem ) <= ( HB_LONG ) lValue;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem ) )
{
* pfValue = hb_vmPopNumber() <= ( double ) lValue;
}
else if( hb_objHasOperator( pItem, HB_OO_OP_LESSEQUAL ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_LESSEQUAL, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
return hb_xvmPopLogical( pfValue );
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1074, NULL, "<=", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
return hb_xvmPopLogical( pfValue );
}
}
HB_XVM_RETURN
}
| hvm.c | 8372 |
HB_EXPORT BOOL | hb_xvmGreater( void )
HB_EXPORT BOOL hb_xvmGreater( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmGreater()"));
hb_vmGreater();
HB_XVM_RETURN
}
| hvm.c | 8415 |
HB_EXPORT BOOL | hb_xvmGreaterThenInt( LONG lValue )
HB_EXPORT BOOL hb_xvmGreaterThenInt( LONG lValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmGreaterThenInt(%ld)", lValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NUMINT( pItem ) )
{
pItem->item.asLogical.value = HB_ITEM_GET_NUMINTRAW( pItem ) > ( HB_LONG ) lValue;
pItem->type = HB_IT_LOGICAL;
}
else if( HB_IS_NUMERIC( pItem ) )
{
hb_vmPushLogical( hb_vmPopNumber() > ( double ) lValue );
}
else if( hb_objHasOperator( pItem, HB_OO_OP_GREATER ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_GREATER, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1075, NULL, ">", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
}
}
HB_XVM_RETURN
}
| hvm.c | 8424 |
HB_EXPORT BOOL | hb_xvmGreaterThenIntIs( LONG lValue, BOOL * pfValue )
HB_EXPORT BOOL hb_xvmGreaterThenIntIs( LONG lValue, BOOL * pfValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmGreaterThenIntIs(%ld,%p)", lValue, pfValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NUMINT( pItem ) )
{
* pfValue = HB_ITEM_GET_NUMINTRAW( pItem ) > ( HB_LONG ) lValue;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem ) )
{
* pfValue = hb_vmPopNumber() > ( double ) lValue;
}
else if( hb_objHasOperator( pItem, HB_OO_OP_GREATER ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_GREATER, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
return hb_xvmPopLogical( pfValue );
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1075, NULL, ">", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
return hb_xvmPopLogical( pfValue );
}
}
HB_XVM_RETURN
}
| hvm.c | 8465 |
HB_EXPORT BOOL | hb_xvmGreaterEqual( void )
HB_EXPORT BOOL hb_xvmGreaterEqual( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmGreaterEqual()"));
hb_vmGreaterEqual();
HB_XVM_RETURN
}
| hvm.c | 8508 |
HB_EXPORT BOOL | hb_xvmGreaterEqualThenInt( LONG lValue )
HB_EXPORT BOOL hb_xvmGreaterEqualThenInt( LONG lValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmGreaterEqualThenInt(%ld)", lValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NUMINT( pItem ) )
{
pItem->item.asLogical.value = HB_ITEM_GET_NUMINTRAW( pItem ) >= ( HB_LONG ) lValue;
pItem->type = HB_IT_LOGICAL;
}
else if( HB_IS_NUMERIC( pItem ) )
{
hb_vmPushLogical( hb_vmPopNumber() >= ( double ) lValue );
}
else if( hb_objHasOperator( pItem, HB_OO_OP_GREATEREQUAL ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_GREATEREQUAL, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1076, NULL, ">=", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
}
}
HB_XVM_RETURN
}
| hvm.c | 8517 |
HB_EXPORT BOOL | hb_xvmGreaterEqualThenIntIs( LONG lValue, BOOL * pfValue )
HB_EXPORT BOOL hb_xvmGreaterEqualThenIntIs( LONG lValue, BOOL * pfValue )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmGreaterEqualThenIntIs(%ld,%p)", lValue, pfValue));
pItem = hb_stackItemFromTop( -1 );
if( HB_IS_NUMINT( pItem ) )
{
* pfValue = HB_ITEM_GET_NUMINTRAW( pItem ) >= ( HB_LONG ) lValue;
hb_stackDec();
}
else if( HB_IS_NUMERIC( pItem ) )
{
* pfValue = hb_vmPopNumber() >= ( double ) lValue;
}
else if( hb_objHasOperator( pItem, HB_OO_OP_GREATEREQUAL ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_GREATEREQUAL, pItem, pItem,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
return hb_xvmPopLogical( pfValue );
}
else
{
PHB_ITEM pResult;
hb_vmPushLong( lValue );
pResult = hb_errRT_BASE_Subst( EG_ARG, 1074, NULL, "<=", 2, pItem, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop();
hb_itemMove( pItem, pResult );
hb_itemRelease( pResult );
return hb_xvmPopLogical( pfValue );
}
}
HB_XVM_RETURN
}
| hvm.c | 8558 |
HB_EXPORT BOOL | hb_xvmInstring( void )
HB_EXPORT BOOL hb_xvmInstring( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmInstring()"));
hb_vmInstring();
HB_XVM_RETURN
}
| hvm.c | 8601 |
HB_EXPORT BOOL | hb_xvmAddInt( LONG lAdd )
HB_EXPORT BOOL hb_xvmAddInt( LONG lAdd )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmAddInt(%ld)", lAdd));
hb_vmAddInt( hb_stackItemFromTop( -1 ), lAdd );
HB_XVM_RETURN
}
| hvm.c | 8610 |
HB_EXPORT BOOL | hb_xvmPlus( void )
HB_EXPORT BOOL hb_xvmPlus( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPlus()"));
hb_vmPlus( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ),
hb_stackItemFromTop( -1 ) );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8619 |
HB_EXPORT BOOL | hb_xvmPlusEq( void )
HB_EXPORT BOOL hb_xvmPlusEq( void )
{
PHB_ITEM pResult, pValue;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPlusEq()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmPlus( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8630 |
HB_EXPORT BOOL | hb_xvmPlusEqPop( void )
HB_EXPORT BOOL hb_xvmPlusEqPop( void )
{
PHB_ITEM pResult;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPlusEqPop()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmPlus( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8646 |
HB_EXPORT BOOL | hb_xvmMinus( void )
HB_EXPORT BOOL hb_xvmMinus( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMinus()"));
hb_vmMinus( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ),
hb_stackItemFromTop( -1 ) );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8660 |
HB_EXPORT BOOL | hb_xvmMinusEq( void )
HB_EXPORT BOOL hb_xvmMinusEq( void )
{
PHB_ITEM pResult, pValue;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMinusEq()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmMinus( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8671 |
HB_EXPORT BOOL | hb_xvmMinusEqPop( void )
HB_EXPORT BOOL hb_xvmMinusEqPop( void )
{
PHB_ITEM pResult;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMinusEqPop()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmMinus( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8687 |
HB_EXPORT BOOL | hb_xvmMultByInt( LONG lValue )
HB_EXPORT BOOL hb_xvmMultByInt( LONG lValue )
{
PHB_ITEM pValue;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMultByInt(%ld)", lValue));
pValue = hb_stackItemFromTop( -1 );
if( HB_IS_NUMERIC( pValue ) )
{
int iDec;
double dValue = hb_itemGetNDDec( pValue, &iDec );
hb_itemPutNumType( pValue, dValue * lValue, iDec,
HB_ITEM_TYPERAW( pValue ), HB_IT_INTEGER );
}
else if( hb_objHasOperator( pValue, HB_OO_OP_MULT ) )
{
hb_vmPushLong( lValue );
hb_objOperatorCall( HB_OO_OP_MULT, pValue, pValue,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
}
else
{
PHB_ITEM pSubst;
hb_vmPushLong( lValue );
pSubst = hb_errRT_BASE_Subst( EG_ARG, 1083, NULL, "*", 2, pValue, hb_stackItemFromTop( -1 ) );
if( pSubst )
{
hb_stackPop();
hb_itemMove( pValue, pSubst );
hb_itemRelease( pSubst );
}
}
HB_XVM_RETURN
}
| hvm.c | 8701 |
HB_EXPORT BOOL | hb_xvmMult( void )
HB_EXPORT BOOL hb_xvmMult( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMult()"));
hb_vmMult( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8742 |
HB_EXPORT BOOL | hb_xvmMultEq( void )
HB_EXPORT BOOL hb_xvmMultEq( void )
{
PHB_ITEM pResult, pValue;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMultEq()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmMult( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8752 |
HB_EXPORT BOOL | hb_xvmMultEqPop( void )
HB_EXPORT BOOL hb_xvmMultEqPop( void )
{
PHB_ITEM pResult;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMultEqPop()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmMult( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8768 |
HB_EXPORT BOOL | hb_xvmDivideByInt( LONG lDivisor )
HB_EXPORT BOOL hb_xvmDivideByInt( LONG lDivisor )
{
PHB_ITEM pValue;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmDivideByInt(%ld)", lDivisor));
pValue = hb_stackItemFromTop( -1 );
if( HB_IS_NUMERIC( pValue ) )
{
if( lDivisor == 0 )
{
PHB_ITEM pSubst;
hb_vmPushLong( lDivisor );
pSubst = hb_errRT_BASE_Subst( EG_ZERODIV, 1340, NULL, "/", 2, pValue, hb_stackItemFromTop( -1 ) );
if( pSubst )
{
hb_stackPop();
hb_itemMove( pValue, pSubst );
hb_itemRelease( pSubst );
}
}
else
{
hb_itemPutND( pValue, hb_itemGetND( pValue ) / lDivisor );
}
}
else if( hb_objHasOperator( pValue, HB_OO_OP_DIVIDE ) )
{
hb_vmPushLong( lDivisor );
hb_objOperatorCall( HB_OO_OP_DIVIDE, pValue, pValue,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
}
else
{
PHB_ITEM pSubst;
hb_vmPushLong( lDivisor );
pSubst = hb_errRT_BASE_Subst( EG_ARG, 1084, NULL, "/", 2, pValue, hb_stackItemFromTop( -1 ) );
if( pSubst )
{
hb_stackPop();
hb_itemMove( pValue, pSubst );
hb_itemRelease( pSubst );
}
}
HB_XVM_RETURN
}
| hvm.c | 8782 |
HB_EXPORT BOOL | hb_xvmDivide( void )
HB_EXPORT BOOL hb_xvmDivide( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmDivide()"));
hb_vmDivide( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8836 |
HB_EXPORT BOOL | hb_xvmDivEq( void )
HB_EXPORT BOOL hb_xvmDivEq( void )
{
PHB_ITEM pResult, pValue;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmDivEq()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmDivide( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8846 |
HB_EXPORT BOOL | hb_xvmDivEqPop( void )
HB_EXPORT BOOL hb_xvmDivEqPop( void )
{
PHB_ITEM pResult;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmDivEqPop()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmDivide( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8862 |
HB_EXPORT BOOL | hb_xvmModulus( void )
HB_EXPORT BOOL hb_xvmModulus( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmModulus()"));
hb_vmModulus( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8876 |
HB_EXPORT BOOL | hb_xvmModEq( void )
HB_EXPORT BOOL hb_xvmModEq( void )
{
PHB_ITEM pResult, pValue;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmModEq()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmModulus( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8886 |
HB_EXPORT BOOL | hb_xvmModEqPop( void )
HB_EXPORT BOOL hb_xvmModEqPop( void )
{
PHB_ITEM pResult;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmModEqPop()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmModulus( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8902 |
HB_EXPORT BOOL | hb_xvmPower( void )
HB_EXPORT BOOL hb_xvmPower( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPower()"));
hb_vmPower( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8916 |
HB_EXPORT BOOL | hb_xvmExpEq( void )
HB_EXPORT BOOL hb_xvmExpEq( void )
{
PHB_ITEM pResult, pValue;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmExpEq()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
pValue = hb_stackItemFromTop( -1 );
hb_vmPower( pResult, pResult, pValue );
hb_itemCopy( pValue, pResult );
hb_itemMove( hb_stackItemFromTop( -2 ), pValue );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8926 |
HB_EXPORT BOOL | hb_xvmExpEqPop( void )
HB_EXPORT BOOL hb_xvmExpEqPop( void )
{
PHB_ITEM pResult;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmExpEqPop()"));
pResult = hb_itemUnRef( hb_stackItemFromTop( -2 ) );
hb_vmPower( pResult, pResult, hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8942 |
HB_EXPORT BOOL | hb_xvmInc( void )
HB_EXPORT BOOL hb_xvmInc( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmInc()"));
hb_vmInc( hb_stackItemFromTop( -1 ) );
HB_XVM_RETURN
}
| hvm.c | 8956 |
HB_EXPORT BOOL | hb_xvmIncEq( void )
HB_EXPORT BOOL hb_xvmIncEq( void )
{
PHB_ITEM pResult, pValue, pTemp;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmIncEq()"));
pResult = hb_stackItemFromTop( -1 );
pValue = hb_itemUnRef( pResult );
hb_vmInc( pValue );
pTemp = hb_stackAllocItem();
hb_itemCopy( pTemp, pValue );
hb_itemMove( pResult, pTemp );
hb_stackDec();
HB_XVM_RETURN
}
| hvm.c | 8965 |
HB_EXPORT BOOL | hb_xvmIncEqPop( void )
HB_EXPORT BOOL hb_xvmIncEqPop( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmIncEqPop()"));
hb_vmInc( hb_itemUnRef( hb_stackItemFromTop( -1 ) ) );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 8982 |
HB_EXPORT BOOL | hb_xvmDec( void )
HB_EXPORT BOOL hb_xvmDec( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmDec()"));
hb_vmDec( hb_stackItemFromTop( -1 ) );
HB_XVM_RETURN
}
| hvm.c | 8992 |
HB_EXPORT BOOL | hb_xvmDecEq( void )
HB_EXPORT BOOL hb_xvmDecEq( void )
{
PHB_ITEM pResult, pValue, pTemp;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmDecEq()"));
pResult = hb_stackItemFromTop( -1 );
pValue = hb_itemUnRef( pResult );
hb_vmDec( pValue );
pTemp = hb_stackAllocItem();
hb_itemCopy( pTemp, pValue );
hb_itemMove( pResult, pTemp );
hb_stackDec();
HB_XVM_RETURN
}
| hvm.c | 9001 |
HB_EXPORT BOOL | hb_xvmDecEqPop( void )
HB_EXPORT BOOL hb_xvmDecEqPop( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmDecEqPop()"));
hb_vmDec( hb_itemUnRef( hb_stackItemFromTop( -1 ) ) );
hb_stackPop();
HB_XVM_RETURN
}
| hvm.c | 9018 |
HB_EXPORT VOID | hb_xvmArrayDim( USHORT uiDimensions )
HB_EXPORT void hb_xvmArrayDim( USHORT uiDimensions )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayDim(%hu)", uiDimensions));
hb_vmArrayDim( uiDimensions );
}
| hvm.c | 9028 |
HB_EXPORT VOID | hb_xvmArrayGen( ULONG ulElements )
HB_EXPORT void hb_xvmArrayGen( ULONG ulElements )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayGen(%lu)", ulElements));
hb_vmArrayGen( ulElements );
}
| hvm.c | 9035 |
HB_EXPORT VOID | hb_xvmHashGen( ULONG ulElements )
HB_EXPORT void hb_xvmHashGen( ULONG ulElements )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmHashGen(%lu)", ulElements));
hb_vmHashGen( ulElements );
}
| hvm.c | 9042 |
STATIC VOID | hb_vmArrayItemPush( ULONG ulIndex )
static void hb_vmArrayItemPush( ULONG ulIndex )
{
PHB_ITEM pArray;
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayItemPush(%lu)", ulIndex));
pArray = hb_stackItemFromTop( -1 );
if( HB_IS_ARRAY( pArray ) )
{
if( HB_IS_OBJECT( pArray ) && hb_objHasOperator( pArray, HB_OO_OP_ARRAYINDEX ) )
{
hb_vmPushNumInt( ulIndex );
hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray,
hb_stackItemFromTop( -1 ), NULL );
hb_stackPop();
return;
}
if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->ulLen ) )
{
if( hb_gcRefCount( pArray->item.asArray.value ) > 1 )
{
/* this is a temporary copy of an array - we can overwrite
* it with no problem
*/
hb_itemCopy( pArray, pArray->item.asArray.value->pItems + ulIndex - 1 );
}
else
{
/* this is a constant array { 1, 2, 3 } - we cannot use
* the optimization here
*/
PHB_ITEM pItem = hb_stackAllocItem();
hb_itemMove( pItem, pArray->item.asArray.value->pItems + ulIndex - 1 );
hb_itemMove( pArray, pItem );
hb_stackDec();
}
}
else
{
hb_vmPushNumInt( ulIndex );
if( !HB_IS_OBJECT( pArray ) &&
hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray,
hb_stackItemFromTop( -1 ), NULL ) )
hb_stackPop();
else
#ifdef HB_C52_STRICT
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 0 );
#else
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ),
2, pArray, hb_stackItemFromTop( -1 ) );
#endif
}
}
else if( HB_IS_HASH( pArray ) )
{
PHB_ITEM pValue;
hb_vmPushNumInt( ulIndex );
pValue = hb_hashGetItemPtr( pArray, hb_stackItemFromTop( -1 ), HB_HASH_AUTOADD_ACCESS );
if( pValue )
{
hb_itemCopy( hb_stackItemFromTop( -1 ), pValue );
hb_itemMove( pArray, hb_stackItemFromTop( -1 ) );
hb_stackDec();
}
else if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray,
hb_stackItemFromTop( -1 ), NULL ) )
hb_stackPop();
else
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 2, pArray, hb_stackItemFromTop( -1 ) );
}
else
{
hb_vmPushNumInt( ulIndex );
if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray,
hb_stackItemFromTop( -1 ), NULL ) )
hb_stackPop();
else
hb_errRT_BASE( EG_ARG, 1068, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ), 2, pArray, hb_stackItemFromTop( -1 ) );
}
}
| hvm.c | 9049 |
STATIC VOID | hb_vmArrayItemPop( ULONG ulIndex )
static void hb_vmArrayItemPop( ULONG ulIndex )
{
PHB_ITEM pValue;
PHB_ITEM pArray;
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayItemPop(%lu", ulIndex));
pValue = hb_stackItemFromTop( -2 );
pArray = hb_stackItemFromTop( -1 );
if( HB_IS_BYREF( pArray ) )
pArray = hb_itemUnRef( pArray );
if( HB_IS_ARRAY( pArray ) )
{
if( HB_IS_OBJECT( pArray ) && hb_objHasOperator( pArray, HB_OO_OP_ARRAYINDEX ) )
{
hb_vmPushNumInt( ulIndex );
hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray,
hb_stackItemFromTop( -1 ), pValue );
hb_stackPop();
hb_stackPop();
hb_stackPop();
return;
}
if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->ulLen ) )
{
pValue->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT );
hb_itemMoveRef( pArray->item.asArray.value->pItems + ulIndex - 1, pValue );
hb_stackPop();
hb_stackDec(); /* value was moved above hb_stackDec() is enough */
}
else
{
hb_vmPushNumInt( ulIndex );
if( !HB_IS_OBJECT( pArray ) &&
hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray,
hb_stackItemFromTop( -1 ), pValue ) )
{
hb_stackPop();
hb_stackPop();
hb_stackPop();
}
else
#ifdef HB_C52_STRICT
hb_errRT_BASE( EG_BOUND, 1133, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 0 );
#else
hb_errRT_BASE( EG_BOUND, 1133, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ),
1, hb_stackItemFromTop( -1 ) );
#endif
}
}
else if( HB_IS_HASH( pArray ) )
{
PHB_ITEM pDest;
hb_vmPushNumInt( ulIndex );
pDest = hb_hashGetItemPtr( pArray, hb_stackItemFromTop( -1 ), HB_HASH_AUTOADD_ASSIGN );
if( pDest )
{
pValue->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT );
hb_itemMoveRef( pDest, pValue );
hb_stackPop();
hb_stackPop();
hb_stackDec(); /* value was moved above hb_stackDec() is enough */
}
else if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray,
hb_stackItemFromTop( -1 ), pValue ) )
{
hb_stackPop();
hb_stackPop();
hb_stackPop();
}
else
hb_errRT_BASE( EG_BOUND, 1133, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 3, pArray, hb_stackItemFromTop( -1 ), pValue );
}
else
{
hb_vmPushNumInt( ulIndex );
if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray,
hb_stackItemFromTop( -1 ), pValue ) )
{
hb_stackPop();
hb_stackPop();
hb_stackPop();
}
else
hb_errRT_BASE( EG_ARG, 1069, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ),
1, hb_stackItemFromTop( -1 ) );
}
}
| hvm.c | 9135 |
HB_EXPORT BOOL | hb_xvmArrayPush( void )
HB_EXPORT BOOL hb_xvmArrayPush( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayPush()"));
hb_vmArrayPush();
HB_XVM_RETURN
}
| hvm.c | 9230 |
HB_EXPORT BOOL | hb_xvmArrayPushRef( void )
HB_EXPORT BOOL hb_xvmArrayPushRef( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayPushRef()"));
hb_vmArrayPushRef();
HB_XVM_RETURN
}
| hvm.c | 9239 |
HB_EXPORT BOOL | hb_xvmArrayItemPush( ULONG ulIndex )
HB_EXPORT BOOL hb_xvmArrayItemPush( ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayItemPush(%lu)", ulIndex));
hb_vmArrayItemPush( ulIndex );
HB_XVM_RETURN
}
| hvm.c | 9248 |
HB_EXPORT BOOL | hb_xvmArrayPop( void )
HB_EXPORT BOOL hb_xvmArrayPop( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayPop()"));
hb_vmArrayPop();
HB_XVM_RETURN
}
| hvm.c | 9257 |
HB_EXPORT BOOL | hb_xvmArrayItemPop( ULONG ulIndex )
HB_EXPORT BOOL hb_xvmArrayItemPop( ULONG ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayItemPop(%lu)", ulIndex));
hb_vmArrayItemPop( ulIndex );
HB_XVM_RETURN
}
| hvm.c | 9266 |
HB_EXPORT VOID | hb_xvmPushDouble( double dNumber, int iWidth, int iDec )
HB_EXPORT void hb_xvmPushDouble( double dNumber, int iWidth, int iDec )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushDouble(%lf, %d, %d)", dNumber, iWidth, iDec));
hb_vmPushDoubleConst( dNumber, iWidth, iDec );
}
| hvm.c | 9275 |
HB_EXPORT VOID | hb_xvmPushLongLong( double dNumber )
HB_EXPORT void hb_xvmPushLongLong( double dNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushLongLong(%l.0f)", dNumber));
hb_vmPushDoubleConst( dNumber, HB_DEFAULT_WIDTH, 0 );
}
| hvm.c | 9283 |
HB_EXPORT VOID | hb_xvmPushLongLong( LONGLONG llNumber )
HB_EXPORT void hb_xvmPushLongLong( LONGLONG llNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushLongLong(%" PFLL "i)", llNumber));
hb_vmPushLongLongConst( llNumber );
}
| hvm.c | 9290 |
HB_EXPORT VOID | hb_xvmLocalName( USHORT uiLocal, char * szLocalName )
HB_EXPORT void hb_xvmLocalName( USHORT uiLocal, char * szLocalName )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmLocalName(%hu, %s)", uiLocal, szLocalName));
hb_vmLocalName( uiLocal, szLocalName );
}
| hvm.c | 9298 |
HB_EXPORT VOID | hb_xvmStaticName( BYTE bIsGlobal, USHORT uiStatic, char * szStaticName )
HB_EXPORT void hb_xvmStaticName( BYTE bIsGlobal, USHORT uiStatic, char * szStaticName )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmStaticName(%d, %hu, %s)", (int)bIsGlobal, uiStatic, szStaticName));
hb_vmStaticName( bIsGlobal, uiStatic, szStaticName );
}
| hvm.c | 9305 |
HB_EXPORT VOID | hb_xvmModuleName( char * szModuleName )
HB_EXPORT void hb_xvmModuleName( char * szModuleName )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmModuleName(%s)", szModuleName));
hb_vmModuleName( szModuleName );
}
| hvm.c | 9312 |
HB_EXPORT BOOL | hb_xvmMacroArrayGen( USHORT uiArgSets )
HB_EXPORT BOOL hb_xvmMacroArrayGen( USHORT uiArgSets )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroArrayGen(%hu)", uiArgSets));
hb_vmMacroArrayGen( uiArgSets );
HB_XVM_RETURN
}
| hvm.c | 9319 |
HB_EXPORT BOOL | hb_xvmMacroDo( USHORT uiArgSets )
HB_EXPORT BOOL hb_xvmMacroDo( USHORT uiArgSets )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroDo(%hu)", uiArgSets));
hb_vmMacroDo( uiArgSets );
HB_XVM_RETURN
}
| hvm.c | 9328 |
HB_EXPORT BOOL | hb_xvmMacroFunc( USHORT uiArgSets )
HB_EXPORT BOOL hb_xvmMacroFunc( USHORT uiArgSets )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroFunc(%hu)", uiArgSets));
hb_vmMacroFunc( uiArgSets );
HB_XVM_RETURN
}
| hvm.c | 9337 |
HB_EXPORT BOOL | hb_xvmMacroSend( USHORT uiArgSets )
HB_EXPORT BOOL hb_xvmMacroSend( USHORT uiArgSets )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroSend(%hu)", uiArgSets));
hb_vmMacroSend( uiArgSets );
HB_XVM_RETURN
}
| hvm.c | 9346 |
HB_EXPORT BOOL | hb_xvmMacroPush( BYTE bFlags )
HB_EXPORT BOOL hb_xvmMacroPush( BYTE bFlags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroPush(%d)", bFlags));
hb_macroGetValue( hb_stackItemFromTop( -1 ), 0, bFlags );
HB_XVM_RETURN
}
| hvm.c | 9355 |
HB_EXPORT BOOL | hb_xvmMacroPushRef( void )
HB_EXPORT BOOL hb_xvmMacroPushRef( void )
{
PHB_ITEM pMacro;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroPushRef()"));
pMacro = hb_stackItemFromTop( -1 );
hb_macroPushSymbol( pMacro );
if( hb_stackGetActionRequest() == 0 )
hb_memvarGetRefer( pMacro, pMacro->item.asSymbol.value );
HB_XVM_RETURN
}
| hvm.c | 9364 |
HB_EXPORT BOOL | hb_xvmMacroPushIndex( void )
HB_EXPORT BOOL hb_xvmMacroPushIndex( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroPushIndex()"));
hb_vmMacroPushIndex();
HB_XVM_RETURN
}
| hvm.c | 9378 |
HB_EXPORT BOOL | hb_xvmMacroPushList( BYTE bFlags )
HB_EXPORT BOOL hb_xvmMacroPushList( BYTE bFlags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroPushList(%d)", bFlags));
hb_macroGetValue( hb_stackItemFromTop( -1 ), HB_P_MACROPUSHLIST, bFlags );
HB_XVM_RETURN
}
| hvm.c | 9387 |
HB_EXPORT BOOL | hb_xvmMacroPushPare( BYTE bFlags )
HB_EXPORT BOOL hb_xvmMacroPushPare( BYTE bFlags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroPushPare(%d)", bFlags));
hb_macroGetValue( hb_stackItemFromTop( -1 ), HB_P_MACROPUSHPARE, bFlags );
HB_XVM_RETURN
}
| hvm.c | 9396 |
HB_EXPORT BOOL | hb_xvmMacroPushAliased( BYTE bFlags )
HB_EXPORT BOOL hb_xvmMacroPushAliased( BYTE bFlags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroPushAliased(%d)", bFlags));
hb_macroPushAliasedValue( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ), bFlags );
HB_XVM_RETURN
}
| hvm.c | 9405 |
HB_EXPORT BOOL | hb_xvmMacroPop( BYTE bFlags )
HB_EXPORT BOOL hb_xvmMacroPop( BYTE bFlags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroPop(%d)", bFlags));
hb_macroSetValue( hb_stackItemFromTop( -1 ), bFlags );
HB_XVM_RETURN
}
| hvm.c | 9414 |
HB_EXPORT BOOL | hb_xvmMacroPopAliased( BYTE bFlags )
HB_EXPORT BOOL hb_xvmMacroPopAliased( BYTE bFlags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroPopAliased(%d)", bFlags));
hb_macroPopAliasedValue( hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ), bFlags );
HB_XVM_RETURN
}
| hvm.c | 9423 |
HB_EXPORT BOOL | hb_xvmMacroSymbol( void )
HB_EXPORT BOOL hb_xvmMacroSymbol( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroSymbol()"));
hb_macroPushSymbol( hb_stackItemFromTop( -1 ) );
HB_XVM_RETURN
}
| hvm.c | 9432 |
HB_EXPORT BOOL | hb_xvmMacroText( void )
HB_EXPORT BOOL hb_xvmMacroText( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmMacroText()"));
hb_macroTextValue( hb_stackItemFromTop( -1 ) );
HB_XVM_RETURN
}
| hvm.c | 9441 |
HB_EXPORT VOID | hb_xvmPushVParams( void )
HB_EXPORT void hb_xvmPushVParams( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushVParams()"));
hb_vmPushVParams();
}
| hvm.c | 9450 |
HB_EXPORT VOID | hb_xvmWithObjectStart( void )
HB_EXPORT void hb_xvmWithObjectStart( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmWithObjectStart()"));
hb_vmWithObjectStart();
}
| hvm.c | 9456 |
HB_EXPORT VOID | hb_xvmWithObjectEnd( void )
HB_EXPORT void hb_xvmWithObjectEnd( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmWithObjectEnd()"));
hb_stackPop(); /* remove with object envelope */
hb_stackPop(); /* remove implicit object */
}
| hvm.c | 9463 |
HB_EXPORT VOID | hb_xvmWithObjectMessage( PHB_SYMB pSymbol )
HB_EXPORT void hb_xvmWithObjectMessage( PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmWithObjectMessage(%p)", pSymbol));
if( pSymbol )
hb_vmPushSymbol( pSymbol );
hb_vmPush( hb_stackWithObjectItem() );
}
| hvm.c | 9471 |
HB_EXPORT ULONG | hb_vmFlagEnabled( ULONG flags )
HB_EXPORT ULONG hb_vmFlagEnabled( ULONG flags )
{
return s_VMFlags & flags;
}
| hvm.c | 9483 |
HB_EXPORT VOID | hb_vmFlagSet( ULONG flags )
HB_EXPORT void hb_vmFlagSet( ULONG flags )
{
s_VMFlags |= flags;
}
| hvm.c | 9488 |
HB_EXPORT VOID | hb_vmFlagClear( ULONG flags )
HB_EXPORT void hb_vmFlagClear( ULONG flags )
{
s_VMFlags &= ~flags;
}
/* ------------------------------------------------------------------------ */
/* The debugger support functions */
| hvm.c | 9493 |
VOID | hb_vmRequestDebug( void )
void hb_vmRequestDebug( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmRequestDebug()"));
s_bDebugRequest = TRUE;
}
| hvm.c | 9502 |
HB_EXPORT BOOL | hb_dbg_InvokeDebug( BOOL bInvoke )
HB_EXPORT BOOL hb_dbg_InvokeDebug( BOOL bInvoke )
{
BOOL bRequest = s_bDebugRequest;
s_bDebugRequest = bInvoke;
return bRequest;
}
| hvm.c | 9508 |
HB_EXPORT HB_DBGENTRY_FUNC | hb_dbg_SetEntry( HB_DBGENTRY_FUNC pFunDbgEntry )
HB_EXPORT HB_DBGENTRY_FUNC hb_dbg_SetEntry( HB_DBGENTRY_FUNC pFunDbgEntry )
{
HB_DBGENTRY_FUNC pPrevFunc = s_pFunDbgEntry;
HB_TRACE(HB_TR_DEBUG, ("hb_dbg_SetEntry(%p)", pFunDbgEntry));
s_pFunDbgEntry = pFunDbgEntry;
return pPrevFunc;
}
| hvm.c | 9516 |
HB_EXPORT PHB_ITEM | hb_dbg_vmVarSGet( int nStatic, int nOffset )
HB_EXPORT PHB_ITEM hb_dbg_vmVarSGet( int nStatic, int nOffset )
{
return hb_arrayGetItemPtr( &s_aStatics, nStatic + nOffset );
}
| hvm.c | 9526 |
HB_EXPORT ULONG | hb_dbg_ProcLevel( void )
HB_EXPORT ULONG hb_dbg_ProcLevel( void )
{
return hb_stackCallDepth();
}
| hvm.c | 9531 |
HB_FUNC | HB_DBG_INVOKEDEBUG(void)
HB_FUNC( HB_DBG_INVOKEDEBUG )
{
BOOL bRequest = s_bDebugRequest;
if( hb_pcount() > 0 )
s_bDebugRequest = hb_parl( 1 );
else
s_bDebugRequest = FALSE;
hb_retl( bRequest );
}
| hvm.c | 9536 |
HB_FUNC | HB_DBG_VMVARSLIST(void)
HB_FUNC( HB_DBG_VMVARSLIST )
{
PHB_ITEM pStatics = hb_itemClone( &s_aStatics );
hb_itemReturnRelease( pStatics );
}
| hvm.c | 9550 |
HB_FUNC | HB_DBG_VMVARSLEN(void)
HB_FUNC( HB_DBG_VMVARSLEN )
{
hb_retnl( hb_arrayLen( &s_aStatics ) );
}
| hvm.c | 9561 |
HB_FUNC | HB_DBG_VMVARSGET(void)
HB_FUNC( HB_DBG_VMVARSGET )
{
hb_itemReturn( hb_dbg_vmVarSGet( hb_parni( 1 ), hb_parni( 2 ) ) );
}
| hvm.c | 9570 |
HB_FUNC | HB_DBG_VMVARSSET(void)
HB_FUNC( HB_DBG_VMVARSSET )
{
PHB_ITEM pItem = hb_param( 3, HB_IT_ANY );
if( pItem )
hb_arraySet( &s_aStatics, hb_parni( 1 ) + hb_parni( 2 ), pItem );
}
| hvm.c | 9579 |
HB_FUNC | HB_DBG_PROCLEVEL(void)
HB_FUNC( HB_DBG_PROCLEVEL )
{
hb_retnl( hb_dbg_ProcLevel() - 1 ); /* Don't count self */
}
| hvm.c | 9590 |
HB_EXPORT ULONG | hb_dbg_vmVarGCount( void )
HB_EXPORT ULONG hb_dbg_vmVarGCount( void )
{
#if 0
return hb_arrayLen( &s_aGlobals );
#else
return 0;
#endif
}
| hvm.c | 9595 |
HB_EXPORT PHB_ITEM | hb_dbg_vmVarGGet( int nGlobal, int nOffset )
HB_EXPORT PHB_ITEM hb_dbg_vmVarGGet( int nGlobal, int nOffset )
{
#if 0
return hb_arrayGetItemPtr( &s_aGlobals, nGlobal + nOffset );
#else
HB_SYMBOL_UNUSED( nGlobal );
HB_SYMBOL_UNUSED( nOffset );
return NULL;
#endif
}
| hvm.c | 9609 |
HB_FUNC | HB_DBG_VMVARGLIST(void)
HB_FUNC( HB_DBG_VMVARGLIST )
{
#if 0
PHB_ITEM pGlobals = hb_itemClone( &s_aGlobals );
#else
PHB_ITEM pGlobals = hb_itemArrayNew( 0 );
#endif
hb_itemReturnRelease( pGlobals );
}
| hvm.c | 9620 |
HB_FUNC | HB_DBG_VMVARGGET(void)
HB_FUNC( HB_DBG_VMVARGGET )
{
hb_itemReturn( hb_dbg_vmVarGGet( hb_parni( 1 ), hb_parni( 2 ) ) );
}
| hvm.c | 9635 |
HB_FUNC | HB_DBG_VMVARGSET(void)
HB_FUNC( HB_DBG_VMVARGSET )
{
#if 0
PHB_ITEM pItem = hb_param( 3, HB_IT_ANY );
if( pItem )
hb_arraySet( &s_aGlobals, hb_parni( 1 ) + hb_parni( 2 ), pItem );
#endif
}
/* ------------------------------------------------------------------------ */
/* The garbage collector interface */
| hvm.c | 9640 |
VOID | hb_vmIsStaticRef( void )
void hb_vmIsStaticRef( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmIsStaticRef()"));
/* statics are stored as an item of array type */
hb_gcItemRef( &s_aStatics );
}
| hvm.c | 9654 |
HB_FUNC | __SETPROFILER(void)
HB_FUNC( __SETPROFILER )
{
#ifdef HB_NO_PROFILER
hb_retl( FALSE );
#else
hb_retl( hb_bProfiler );
if( ISLOG( 1 ) )
hb_bProfiler = hb_parl( 1 );
#endif
}
| hvm.c | 9665 |
HB_FUNC | __TRACEPRGCALLS(void)
HB_FUNC( __TRACEPRGCALLS )
{
#ifdef HB_NO_TRACE
hb_retl( FALSE );
#else
hb_retl( hb_bTracePrgCalls );
if( ISLOG( 1 ) )
hb_bTracePrgCalls = hb_parl( 1 );
#endif
}
| hvm.c | 9680 |
HB_FUNC | __OPCOUNT(void)
HB_FUNC( __OPCOUNT ) /* it returns the total amount of opcodes */
{
hb_retnl( HB_P_LAST_PCODE - 1 );
}
HB_FUNC( __OPGETPRF ) /* profiler: It returns an array with an opcode called and
consumed times { nTimes, nTime },
given the opcode index */
{
#ifndef HB_NO_PROFILER
ULONG ulOpcode = hb_parnl( 1 );
hb_reta( 2 );
if( ulOpcode < HB_P_LAST_PCODE )
{
hb_stornl( hb_ulOpcodesCalls[ ulOpcode ], -1, 1 );
hb_stornl( hb_ulOpcodesTime[ ulOpcode ], -1, 2 );
}
else
#else
hb_reta( 2 );
#endif
{
hb_stornl( 0, -1, 1 );
hb_stornl( 0, -1, 2 );
}
}
| hvm.c | 9695 |
HB_FUNC | __VMVARGLIST(void)
HB_FUNC( __VMVARGLIST )
{
HB_FUNC_EXEC( HB_DBG_VMVARGLIST );
}
| hvm.c | 9724 |
HB_FUNC | __VMVARSLIST(void)
HB_FUNC( __VMVARSLIST )
{
HB_FUNC_EXEC( HB_DBG_VMVARSLIST );
}
| hvm.c | 9729 |
HB_FUNC | __VMVARSLEN(void)
HB_FUNC( __VMVARSLEN )
{
HB_FUNC_EXEC( HB_DBG_VMVARSLEN );
}
| hvm.c | 9734 |
HB_FUNC | __VMVARSGET(void)
HB_FUNC( __VMVARSGET )
{
HB_FUNC_EXEC( HB_DBG_VMVARSGET );
}
| hvm.c | 9739 |
HB_FUNC | __VMVARSSET(void)
HB_FUNC( __VMVARSSET )
{
HB_FUNC_EXEC( HB_DBG_VMVARSSET );
}
| hvm.c | 9744 |
HB_FUNC | ERRORLEVEL(void)
HB_FUNC( ERRORLEVEL )
{
hb_retni( s_nErrorLevel );
/* NOTE: This should be ISNUM( 1 ), but it's sort of a Clipper bug that it
accepts other types also and considers them zero. [vszakats] */
if( hb_pcount() >= 1 )
/* Only replace the error level if a parameter was passed */
s_nErrorLevel = hb_parni( 1 );
}
| hvm.c | 9750 |
VOID | hb_vmForceLink( void )
void hb_vmForceLink( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmForceLink()"));
HB_FUNC_EXEC( SYSINIT );
}
#undef HB_FORCE_LINK_MAIN
#if defined(HB_OS_WIN_32) && !defined(__EXPORT__) && \
( defined(__WATCOMC__) || defined(__MINGW32__) )
# define HB_FORCE_LINK_MAIN hb_forceLinkMainWin
#elif defined(HB_OS_LINUX) && defined(__WATCOMC__)
# define HB_FORCE_LINK_MAIN hb_forceLinkMainStd
#endif
#ifdef HB_FORCE_LINK_MAIN
HB_EXTERN_BEGIN
extern HB_EXPORT void HB_FORCE_LINK_MAIN( void );
| hvm.c | 9767 |
HB_EXTERN_END VOID | _hb_forceLinkMain()
HB_EXTERN_END
void _hb_forceLinkMain()
{
HB_FORCE_LINK_MAIN();
}
| hvm.c | 9791 |
initexit.c |
Type | Function | Source | Line |
HB_FUNC | __QUIT(void)
HB_FUNC( __QUIT )
{
hb_vmRequestQuit();
}
| initexit.c | 61 |
initsymb.c |
Type | Function | Source | Line |
VOID | hb_vmSymbolInit_RT( void )
void hb_vmSymbolInit_RT( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmSymbolInit_RT()"));
hb_vmProcessSymbols( symbols, sizeof( symbols ) / sizeof( HB_SYMB ) );
}
| initsymb.c | 190 |
itemapi.c |
Type | Function | Source | Line |
HB_EXPORT PHB_ITEM | hb_itemNew( PHB_ITEM pNull )
HB_EXPORT PHB_ITEM hb_itemNew( PHB_ITEM pNull )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemNew(%p)", pNull));
return hb_gcGripGet( pNull );
}
| itemapi.c | 110 |
HB_EXPORT PHB_ITEM | hb_itemParam( USHORT uiParam )
HB_EXPORT PHB_ITEM hb_itemParam( USHORT uiParam )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemParam(%hu)", uiParam));
return hb_itemNew( hb_param( uiParam, HB_IT_ANY ) );
}
| itemapi.c | 117 |
HB_EXPORT PHB_ITEM | hb_itemParamPtr( USHORT uiParam, long lMask )
HB_EXPORT PHB_ITEM hb_itemParamPtr( USHORT uiParam, long lMask )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemParamPtr(%hu, %ld)", uiParam, lMask));
return hb_param( ( int ) uiParam, lMask );
}
| itemapi.c | 126 |
HB_EXPORT BOOL | hb_itemParamStore( USHORT uiParam, PHB_ITEM pItem )
HB_EXPORT BOOL hb_itemParamStore( USHORT uiParam, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemParamStore(%hu, %p)", uiParam, pItem));
if( hb_param( uiParam, HB_IT_BYREF ) )
{
hb_itemCopyToRef( hb_stackItemFromBase( uiParam ), pItem );
return TRUE;
}
return FALSE;
}
| itemapi.c | 133 |
HB_EXPORT BOOL | hb_itemParamStoreForward( USHORT uiParam, PHB_ITEM pItem )
HB_EXPORT BOOL hb_itemParamStoreForward( USHORT uiParam, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemParamStoreForward(%hu, %p)", uiParam, pItem));
if( hb_param( uiParam, HB_IT_BYREF ) )
{
hb_itemMoveToRef( hb_stackItemFromBase( uiParam ), pItem );
return TRUE;
}
return FALSE;
}
| itemapi.c | 146 |
HB_EXPORT USHORT | hb_itemPCount( void )
HB_EXPORT USHORT hb_itemPCount( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPCount()"));
return ( USHORT ) hb_pcount();
}
| itemapi.c | 159 |
HB_EXPORT BOOL | hb_itemRelease( PHB_ITEM pItem )
HB_EXPORT BOOL hb_itemRelease( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemRelease(%p)", pItem));
if( pItem )
{
hb_gcGripDrop( pItem );
return TRUE;
}
else
return FALSE;
}
| itemapi.c | 166 |
HB_EXPORT PHB_ITEM | hb_itemArrayNew( ULONG ulLen )
HB_EXPORT PHB_ITEM hb_itemArrayNew( ULONG ulLen )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayNew(%lu)", ulLen));
pItem = hb_itemNew( NULL );
hb_arrayNew( pItem, ulLen );
return pItem;
}
| itemapi.c | 179 |
HB_EXPORT PHB_ITEM | hb_itemArrayGet( PHB_ITEM pArray, ULONG ulIndex )
HB_EXPORT PHB_ITEM hb_itemArrayGet( PHB_ITEM pArray, ULONG ulIndex )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayGet(%p, %lu)", pArray, ulIndex));
pItem = hb_itemNew( NULL );
if( pArray )
hb_arrayGet( pArray, ulIndex, pItem );
return pItem;
}
| itemapi.c | 192 |
HB_EXPORT PHB_ITEM | hb_itemArrayPut( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
HB_EXPORT PHB_ITEM hb_itemArrayPut( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayPut(%p, %lu, %p)", pArray, ulIndex, pItem));
if( pArray )
hb_arraySet( pArray, ulIndex, pItem );
return pArray;
}
| itemapi.c | 206 |
HB_EXPORT PHB_ITEM | hb_itemPutC( PHB_ITEM pItem, const char * szText )
HB_EXPORT PHB_ITEM hb_itemPutC( PHB_ITEM pItem, const char * szText )
{
ULONG ulLen, ulAlloc;
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutC(%p, %s)", pItem, szText));
ulLen = szText ? strlen( szText ) : 0;
if( ulLen > 1 )
{
ulAlloc = ulLen + 1;
szText = ( char * ) hb_xmemcpy( hb_xgrab( ulAlloc ), szText, ulAlloc );
}
else
{
ulAlloc = 0;
szText = ( char * ) ( ulLen ? hb_szAscii[ ( unsigned char ) ( szText[0] ) ] : "" );
}
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_STRING;
pItem->item.asString.value = ( char * ) szText;
pItem->item.asString.length = ulLen;
pItem->item.asString.allocated = ulAlloc;
return pItem;
}
| itemapi.c | 216 |
HB_EXPORT PHB_ITEM | hb_itemPutCL( PHB_ITEM pItem, const char * szText, ULONG ulLen )
HB_EXPORT PHB_ITEM hb_itemPutCL( PHB_ITEM pItem, const char * szText, ULONG ulLen )
{
ULONG ulAlloc;
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCL(%p, %s, %lu)", pItem, szText, ulLen));
if( ulLen > 1 )
{
ulAlloc = ulLen + 1;
szText = ( char * ) hb_xmemcpy( hb_xgrab( ulAlloc ), szText, ulLen );
( ( char * ) szText )[ ulLen ] = '\0';
}
else
{
ulAlloc = 0;
szText = ( char * ) ( ulLen ? hb_szAscii[ ( unsigned char ) ( szText[0] ) ] : "" );
}
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
/* NOTE: CA-Cl*pper seems to be buggy here, it will return ulLen bytes of
trash if the szText buffer is NULL, at least with hb_retclen().
[vszakats] */
pItem->type = HB_IT_STRING;
pItem->item.asString.value = ( char * ) szText;
pItem->item.asString.length = ulLen;
pItem->item.asString.allocated = ulAlloc;
return pItem;
}
| itemapi.c | 250 |
HB_EXPORT PHB_ITEM | hb_itemPutCConst( PHB_ITEM pItem, const char * szText )
HB_EXPORT PHB_ITEM hb_itemPutCConst( PHB_ITEM pItem, const char * szText )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCConst(%p, %s)", pItem, szText));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_STRING;
pItem->item.asString.allocated = 0;
if( szText == NULL )
{
pItem->item.asString.value = "";
pItem->item.asString.length = 0;
}
else
{
pItem->item.asString.value = ( char * ) szText;
pItem->item.asString.length = strlen( szText );
}
return pItem;
}
| itemapi.c | 288 |
HB_EXPORT PHB_ITEM | hb_itemPutCLConst( PHB_ITEM pItem, const char * szText, ULONG ulLen )
HB_EXPORT PHB_ITEM hb_itemPutCLConst( PHB_ITEM pItem, const char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCConst(%p, %s, %lu)", pItem, szText, ulLen));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
if( szText == NULL )
{
pItem->item.asString.value = "";
pItem->item.asString.length = 0;
}
else
{
if( szText[ ulLen ] != '\0' )
hb_errInternal( 6003, "Internal error: hb_itemPutCLConst() missing termination character", NULL, NULL );
pItem->item.asString.value = ( char * ) szText;
pItem->item.asString.length = ulLen;
}
pItem->type = HB_IT_STRING;
pItem->item.asString.allocated = 0;
return pItem;
}
| itemapi.c | 317 |
HB_EXPORT PHB_ITEM | hb_itemPutCPtr2( PHB_ITEM pItem, char * szText )
HB_EXPORT PHB_ITEM hb_itemPutCPtr2( PHB_ITEM pItem, char * szText )
{
ULONG ulLen;
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCPtr2(%p, %s)", pItem, szText));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
ulLen = szText ? strlen( szText ) : 0;
pItem->type = HB_IT_STRING;
pItem->item.asString.length = ulLen;
if( ulLen == 0 )
{
pItem->item.asString.allocated = 0;
pItem->item.asString.value = "";
hb_xfree( szText );
}
else if( ulLen == 1 )
{
pItem->item.asString.allocated = 0;
pItem->item.asString.value = ( char * ) hb_szAscii[ (unsigned char) ( szText[0] ) ];
hb_xfree( szText );
}
else
{
szText[ ulLen ] = '\0';
pItem->item.asString.allocated = ulLen + 1;
pItem->item.asString.value = szText;
}
return pItem;
}
| itemapi.c | 349 |
HB_EXPORT PHB_ITEM | hb_itemPutCPtr( PHB_ITEM pItem, char * szText, ULONG ulLen )
HB_EXPORT PHB_ITEM hb_itemPutCPtr( PHB_ITEM pItem, char * szText, ULONG ulLen )
{
return hb_itemPutCLPtr( pItem, szText, ulLen );
}
| itemapi.c | 389 |
HB_EXPORT PHB_ITEM | hb_itemPutCLPtr( PHB_ITEM pItem, char * szText, ULONG ulLen )
HB_EXPORT PHB_ITEM hb_itemPutCLPtr( PHB_ITEM pItem, char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCLPtr(%p, %s, %lu)", pItem, szText, ulLen));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_STRING;
pItem->item.asString.length = ulLen;
if( ulLen == 0 )
{
pItem->item.asString.allocated = 0;
pItem->item.asString.value = "";
hb_xfree( szText );
}
else if( ulLen == 1 )
{
pItem->item.asString.allocated = 0;
pItem->item.asString.value = ( char * ) hb_szAscii[ (unsigned char) ( szText[0] ) ];
hb_xfree( szText );
}
else
{
szText[ ulLen ] = '\0';
pItem->item.asString.allocated = ulLen + 1;
pItem->item.asString.value = szText;
}
return pItem;
}
| itemapi.c | 394 |
HB_EXPORT VOID | hb_itemSetCMemo( PHB_ITEM pItem )
HB_EXPORT void hb_itemSetCMemo( PHB_ITEM pItem )
{
if( pItem && HB_IS_STRING( pItem ) )
pItem->type |= HB_IT_MEMOFLAG;
}
| itemapi.c | 430 |
HB_EXPORT CHAR * | hb_itemGetC( PHB_ITEM pItem )
HB_EXPORT char * hb_itemGetC( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetC(%p)", pItem));
if( pItem && HB_IS_STRING( pItem ) )
{
char * szResult = ( char * ) hb_xgrab( pItem->item.asString.length + 1 );
hb_xmemcpy( szResult, pItem->item.asString.value, pItem->item.asString.length );
szResult[ pItem->item.asString.length ] = '\0';
return szResult;
}
else
return NULL;
}
| itemapi.c | 438 |
HB_EXPORT CHAR * | hb_itemGetCPtr( PHB_ITEM pItem )
HB_EXPORT char * hb_itemGetCPtr( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetCPtr(%p)", pItem));
if( pItem && HB_IS_STRING( pItem ) )
return pItem->item.asString.value;
else
return "";
}
| itemapi.c | 457 |
HB_EXPORT ULONG | hb_itemGetCLen( PHB_ITEM pItem )
HB_EXPORT ULONG hb_itemGetCLen( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetCLen(%p)", pItem));
if( pItem && HB_IS_STRING( pItem ) )
return pItem->item.asString.length;
else
return 0;
}
| itemapi.c | 467 |
HB_EXPORT ULONG | hb_itemCopyC( PHB_ITEM pItem, char * szBuffer, ULONG ulLen )
HB_EXPORT ULONG hb_itemCopyC( PHB_ITEM pItem, char * szBuffer, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyC(%p, %s, %lu)", pItem, szBuffer, ulLen));
if( pItem && HB_IS_STRING( pItem ) )
{
if( ulLen == 0 || ulLen > pItem->item.asString.length )
ulLen = pItem->item.asString.length;
hb_xmemcpy( szBuffer, pItem->item.asString.value, ulLen );
return ulLen;
}
else
return 0;
}
| itemapi.c | 477 |
HB_EXPORT BOOL | hb_itemFreeC( char * szText )
HB_EXPORT BOOL hb_itemFreeC( char * szText )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemFreeC(%s)", szText));
if( szText )
{
hb_xfree( szText );
return TRUE;
}
else
return FALSE;
}
| itemapi.c | 494 |
HB_EXPORT CHAR * | hb_itemGetDS( PHB_ITEM pItem, char * szDate )
HB_EXPORT char * hb_itemGetDS( PHB_ITEM pItem, char * szDate )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetDS(%p, %s)", szDate));
if( pItem && HB_IS_DATE( pItem ) )
return hb_dateDecStr( szDate, pItem->item.asDate.value );
else
return hb_dateDecStr( szDate, 0 );
}
| itemapi.c | 514 |
HB_EXPORT LONG | hb_itemGetDL( PHB_ITEM pItem )
HB_EXPORT long hb_itemGetDL( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetDL(%p)", pItem));
if( pItem && HB_IS_DATE( pItem ) )
return pItem->item.asDate.value;
else
return 0;
}
| itemapi.c | 524 |
HB_EXPORT BOOL | hb_itemGetL( PHB_ITEM pItem )
HB_EXPORT BOOL hb_itemGetL( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetL(%p)", pItem));
if( pItem )
{
if( HB_IS_LOGICAL( pItem ) )
return pItem->item.asLogical.value;
else if( HB_IS_INTEGER( pItem ) )
return pItem->item.asInteger.value != 0;
else if( HB_IS_LONG( pItem ) )
return pItem->item.asLong.value != 0;
else if( HB_IS_DOUBLE( pItem ) )
return pItem->item.asDouble.value != 0.0;
}
return FALSE;
}
| itemapi.c | 534 |
HB_EXPORT DOUBLE | hb_itemGetND( PHB_ITEM pItem )
HB_EXPORT double hb_itemGetND( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetND(%p)", pItem));
if( pItem )
{
if( HB_IS_DOUBLE( pItem ) )
return pItem->item.asDouble.value;
else if( HB_IS_INTEGER( pItem ) )
return ( double ) pItem->item.asInteger.value;
else if( HB_IS_LONG( pItem ) )
return ( double ) pItem->item.asLong.value;
}
return 0;
}
| itemapi.c | 556 |
HB_EXPORT INT | hb_itemGetNI( PHB_ITEM pItem )
HB_EXPORT int hb_itemGetNI( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetNI(%p)", pItem));
if( pItem )
{
if( HB_IS_INTEGER( pItem ) )
return pItem->item.asInteger.value;
else if( HB_IS_LONG( pItem ) )
return ( int ) pItem->item.asLong.value;
else if( HB_IS_DOUBLE( pItem ) )
return ( int ) pItem->item.asDouble.value;
}
return 0;
}
| itemapi.c | 575 |
HB_EXPORT LONG | hb_itemGetNL( PHB_ITEM pItem )
HB_EXPORT LONG hb_itemGetNL( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetNL(%p)", pItem));
if( pItem )
{
if( HB_IS_LONG( pItem ) )
return ( LONG ) pItem->item.asLong.value;
else if( HB_IS_INTEGER( pItem ) )
return ( LONG ) pItem->item.asInteger.value;
else if( HB_IS_DOUBLE( pItem ) )
#ifdef __GNUC__
return ( LONG ) ( ULONG ) pItem->item.asDouble.value;
#else
return ( LONG ) pItem->item.asDouble.value;
#endif
else if( HB_IS_DATE( pItem ) )
return ( LONG ) pItem->item.asDate.value;
}
return 0;
}
| itemapi.c | 594 |
HB_EXPORT HB_LONG | hb_itemGetNInt( PHB_ITEM pItem )
HB_EXPORT HB_LONG hb_itemGetNInt( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetNL(%p)", pItem));
if( pItem )
{
if( HB_IS_LONG( pItem ) )
return ( HB_LONG ) pItem->item.asLong.value;
else if( HB_IS_INTEGER( pItem ) )
return ( HB_LONG ) pItem->item.asInteger.value;
else if( HB_IS_DOUBLE( pItem ) )
#ifdef __GNUC__
return ( HB_LONG ) ( HB_ULONG ) pItem->item.asDouble.value;
#else
return ( HB_LONG ) pItem->item.asDouble.value;
#endif
else if( HB_IS_DATE( pItem ) )
return ( LONG ) pItem->item.asDate.value;
}
return 0;
}
| itemapi.c | 620 |
HB_EXPORT LONGLONG | hb_itemGetNLL( PHB_ITEM pItem )
HB_EXPORT LONGLONG hb_itemGetNLL( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetNL(%p)", pItem));
if( pItem )
{
if( HB_IS_LONG( pItem ) )
return ( LONGLONG ) pItem->item.asLong.value;
else if( HB_IS_INTEGER( pItem ) )
return ( LONGLONG ) pItem->item.asInteger.value;
else if( HB_IS_DOUBLE( pItem ) )
#ifdef __GNUC__
return ( LONGLONG ) ( ULONGLONG ) pItem->item.asDouble.value;
#else
return ( LONGLONG ) pItem->item.asDouble.value;
#endif
else if( HB_IS_DATE( pItem ) )
return ( LONGLONG ) pItem->item.asDate.value;
}
return 0;
}
| itemapi.c | 647 |
HB_EXPORT VOID * | hb_itemGetPtr( PHB_ITEM pItem )
HB_EXPORT void * hb_itemGetPtr( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetPtr(%p)", pItem));
if( pItem && HB_IS_POINTER( pItem ) )
return pItem->item.asPointer.value;
else
return NULL;
}
| itemapi.c | 674 |
HB_EXPORT VOID * | hb_itemGetPtrGC( PHB_ITEM pItem, HB_GARBAGE_FUNC_PTR pFunc )
HB_EXPORT void * hb_itemGetPtrGC( PHB_ITEM pItem, HB_GARBAGE_FUNC_PTR pFunc )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetPtrGC(%p,%p)", pItem, pFunc));
if( pItem && HB_IS_POINTER( pItem ) &&
pItem->item.asPointer.collect &&
hb_gcFunc( pItem->item.asPointer.value ) == pFunc )
return pItem->item.asPointer.value;
else
return NULL;
}
| itemapi.c | 684 |
HB_EXPORT PHB_SYMB | hb_itemGetSymbol( PHB_ITEM pItem )
HB_EXPORT PHB_SYMB hb_itemGetSymbol( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetSymbol(%p)", pItem));
if( pItem && HB_IS_SYMBOL( pItem ) )
return pItem->item.asSymbol.value;
else
return NULL;
}
| itemapi.c | 696 |
HB_EXPORT PHB_ITEM | hb_itemReturn( PHB_ITEM pItem )
HB_EXPORT PHB_ITEM hb_itemReturn( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemReturn(%p)", pItem));
if( pItem )
hb_itemCopy( hb_stackReturnItem(), pItem );
return pItem;
}
| itemapi.c | 706 |
HB_EXPORT PHB_ITEM | hb_itemReturnForward( PHB_ITEM pItem )
HB_EXPORT PHB_ITEM hb_itemReturnForward( PHB_ITEM pItem )
{
HB_TRACE_STEALTH( HB_TR_DEBUG, ("hb_itemReturnForward(%p)", pItem ) );
if( pItem )
hb_itemMove( hb_stackReturnItem(), pItem );
return pItem;
}
| itemapi.c | 716 |
HB_EXPORT VOID | hb_itemReturnRelease( PHB_ITEM pItem )
HB_EXPORT void hb_itemReturnRelease( PHB_ITEM pItem )
{
HB_TRACE_STEALTH( HB_TR_DEBUG, ("hb_itemReturnRelease(%p)", pItem ) );
if( pItem )
{
hb_itemMove( hb_stackReturnItem(), pItem );
hb_itemRelease( pItem );
}
}
| itemapi.c | 726 |
HB_EXPORT PHB_ITEM | hb_itemPutDS( PHB_ITEM pItem, const char * szDate )
HB_EXPORT PHB_ITEM hb_itemPutDS( PHB_ITEM pItem, const char * szDate )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutDS(%p, %s)", pItem, szDate));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_DATE;
pItem->item.asDate.value = hb_dateEncStr( szDate );
return pItem;
}
| itemapi.c | 738 |
HB_EXPORT PHB_ITEM | hb_itemPutD( PHB_ITEM pItem, int iYear, int iMonth, int iDay )
HB_EXPORT PHB_ITEM hb_itemPutD( PHB_ITEM pItem, int iYear, int iMonth, int iDay )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutD(%p, %04i, %02i, %02i)", pItem, iYear, iMonth, iDay));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_DATE;
pItem->item.asDate.value = hb_dateEncode( iYear, iMonth, iDay );
return pItem;
}
| itemapi.c | 756 |
HB_EXPORT PHB_ITEM | hb_itemPutDL( PHB_ITEM pItem, long lJulian )
HB_EXPORT PHB_ITEM hb_itemPutDL( PHB_ITEM pItem, long lJulian )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutDL(%p, %ld)", pItem, lJulian));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_DATE;
pItem->item.asDate.value = lJulian;
return pItem;
}
| itemapi.c | 774 |
HB_EXPORT PHB_ITEM | hb_itemPutL( PHB_ITEM pItem, BOOL bValue )
HB_EXPORT PHB_ITEM hb_itemPutL( PHB_ITEM pItem, BOOL bValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutL(%p, %d)", pItem, (int) bValue));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_LOGICAL;
pItem->item.asLogical.value = bValue;
return pItem;
}
| itemapi.c | 792 |
HB_EXPORT PHB_ITEM | hb_itemPutND( PHB_ITEM pItem, double dNumber )
HB_EXPORT PHB_ITEM hb_itemPutND( PHB_ITEM pItem, double dNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutND(%p, %lf)", pItem, dNumber));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.length = HB_DBL_LENGTH( dNumber );
pItem->item.asDouble.decimal = hb_set.HB_SET_DECIMALS;
pItem->item.asDouble.value = dNumber;
return pItem;
}
| itemapi.c | 810 |
HB_EXPORT PHB_ITEM | hb_itemPutNI( PHB_ITEM pItem, int iNumber )
HB_EXPORT PHB_ITEM hb_itemPutNI( PHB_ITEM pItem, int iNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutNI(%p, %d)", pItem, iNumber));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = iNumber;
pItem->item.asInteger.length = HB_INT_LENGTH( iNumber );
return pItem;
}
| itemapi.c | 830 |
HB_EXPORT PHB_ITEM | hb_itemPutNL( PHB_ITEM pItem, LONG lNumber )
HB_EXPORT PHB_ITEM hb_itemPutNL( PHB_ITEM pItem, LONG lNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutNL(%p, %ld)", pItem, lNumber));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
#if HB_INT_MAX >= LONG_MAX
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = (int) lNumber;
pItem->item.asInteger.length = HB_INT_LENGTH( lNumber );
#else
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = (HB_LONG) lNumber;
pItem->item.asLong.length = HB_LONG_LENGTH( lNumber );
#endif
return pItem;
}
| itemapi.c | 849 |
HB_EXPORT PHB_ITEM | hb_itemPutNLL( PHB_ITEM pItem, LONGLONG llNumber )
HB_EXPORT PHB_ITEM hb_itemPutNLL( PHB_ITEM pItem, LONGLONG llNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutNL(%p, %" PFLL "d)", pItem, llNumber));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
#if HB_LONG_MAX >= LONGLONG_MAX
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = (HB_LONG) llNumber;
pItem->item.asLong.length = HB_LONG_LENGTH( llNumber );
#else
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value = ( double ) llNumber;
pItem->item.asDouble.length = HB_DBL_LENGTH( pItem->item.asDouble.value );
pItem->item.asDouble.decimal = 0;
#endif
return pItem;
}
| itemapi.c | 875 |
HB_EXPORT PHB_ITEM | hb_itemPutNInt( PHB_ITEM pItem, HB_LONG lNumber )
HB_EXPORT PHB_ITEM hb_itemPutNInt( PHB_ITEM pItem, HB_LONG lNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutNInt(%p, %" PFHL "d)", pItem, lNumber));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
if( HB_LIM_INT( lNumber ) )
{
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = ( int ) lNumber;
/* EXP limit used intentionally */
pItem->item.asInteger.length = HB_INT_EXPLENGTH( lNumber );
}
else
{
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = lNumber;
pItem->item.asLong.length = HB_LONG_LENGTH( lNumber );
}
return pItem;
}
| itemapi.c | 901 |
HB_EXPORT PHB_ITEM | hb_itemPutNIntLen( PHB_ITEM pItem, HB_LONG lNumber, int iWidth )
HB_EXPORT PHB_ITEM hb_itemPutNIntLen( PHB_ITEM pItem, HB_LONG lNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutNIntLen(%p, %" PFHL "d, %d)", pItem, lNumber, iWidth));
if( HB_LIM_INT( lNumber ) )
{
return hb_itemPutNILen( pItem, ( int ) lNumber, iWidth );
}
else
{
#ifdef HB_LONG_LONG_OFF
return hb_itemPutNLLen( pItem, ( long ) lNumber, iWidth );
#else
return hb_itemPutNLLLen( pItem, ( LONGLONG ) lNumber, iWidth );
#endif
}
}
| itemapi.c | 930 |
HB_EXPORT PHB_ITEM | hb_itemPutNLen( PHB_ITEM pItem, double dNumber, int iWidth, int iDec )
HB_EXPORT PHB_ITEM hb_itemPutNLen( PHB_ITEM pItem, double dNumber, int iWidth, int iDec )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutNLen(%p, %lf, %d, %d)", pItem, dNumber, iWidth, iDec));
if( iWidth <= 0 || iWidth > 99 )
iWidth = HB_DBL_LENGTH( dNumber );
if( iDec < 0 )
iDec = hb_set.HB_SET_DECIMALS;
if( iDec > 0 )
return hb_itemPutNDLen( pItem, dNumber, iWidth, iDec );
else if( HB_DBL_LIM_INT( dNumber ) )
return hb_itemPutNILen( pItem, ( int ) dNumber, iWidth );
else if( HB_DBL_LIM_LONG( dNumber ) )
#ifdef HB_LONG_LONG_OFF
return hb_itemPutNLLen( pItem, ( long ) dNumber, iWidth );
#else
return hb_itemPutNLLLen( pItem, ( LONGLONG ) dNumber, iWidth );
#endif
else
return hb_itemPutNDLen( pItem, dNumber, iWidth, 0 );
}
| itemapi.c | 948 |
HB_EXPORT PHB_ITEM | hb_itemPutNDLen( PHB_ITEM pItem, double dNumber, int iWidth, int iDec )
HB_EXPORT PHB_ITEM hb_itemPutNDLen( PHB_ITEM pItem, double dNumber, int iWidth, int iDec )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutNDLen(%p, %lf, %d, %d)", pItem, dNumber, iWidth, iDec));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
if( iWidth <= 0 || iWidth > 99 )
{
#if (__BORLANDC__ > 1040) /* Use this only above Borland C++ 3.1 */
/* Borland C compiled app crashes if a "NaN" double is compared with another double [martin vogel] */
if( _isnan( dNumber ) )
{
iWidth = 20;
}
else
#endif
iWidth = HB_DBL_LENGTH( dNumber );
}
if( iDec < 0 )
iDec = hb_set.HB_SET_DECIMALS;
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.length = iWidth;
pItem->item.asDouble.decimal = iDec;
pItem->item.asDouble.value = dNumber;
return pItem;
}
| itemapi.c | 972 |
HB_EXPORT PHB_ITEM | hb_itemPutNDDec( PHB_ITEM pItem, double dNumber, int iDec )
HB_EXPORT PHB_ITEM hb_itemPutNDDec( PHB_ITEM pItem, double dNumber, int iDec )
{
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_itemPutNDDec(%p, %lf, %i)", pItem, dNumber, iDec));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.length = HB_DBL_LENGTH( dNumber );
if( iDec == HB_DEFAULT_DECIMALS )
{
pItem->item.asDouble.decimal = hb_set.HB_SET_DECIMALS;
}
else
{
pItem->item.asDouble.decimal = iDec;
}
pItem->item.asDouble.value = dNumber;
return pItem;
}
| itemapi.c | 1008 |
HB_EXPORT DOUBLE | hb_itemGetNDDec( PHB_ITEM pItem, int * piDec )
HB_EXPORT double hb_itemGetNDDec( PHB_ITEM pItem, int * piDec )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetNDDec(%p,%p)", pItem, piDec));
if( HB_IS_INTEGER( pItem ) )
{
*piDec = 0;
return ( double ) pItem->item.asInteger.value;
}
else if( HB_IS_LONG( pItem ) )
{
*piDec = 0;
return ( double ) pItem->item.asLong.value;
}
else if( HB_IS_DOUBLE( pItem ) )
{
*piDec = pItem->item.asDouble.decimal;
return pItem->item.asDouble.value;
}
*piDec = 0;
return 0.0;
}
| itemapi.c | 1037 |
HB_EXPORT PHB_ITEM | hb_itemPutNILen( PHB_ITEM pItem, int iNumber, int iWidth )
HB_EXPORT PHB_ITEM hb_itemPutNILen( PHB_ITEM pItem, int iNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutNILen(%p, %d, %d)", pItem, iNumber, iWidth));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
if( iWidth <= 0 || iWidth > 99 )
iWidth = HB_INT_LENGTH( iNumber );
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.length = iWidth;
pItem->item.asInteger.value = iNumber;
return pItem;
}
| itemapi.c | 1062 |
HB_EXPORT PHB_ITEM | hb_itemPutNLLen( PHB_ITEM pItem, LONG lNumber, int iWidth )
HB_EXPORT PHB_ITEM hb_itemPutNLLen( PHB_ITEM pItem, LONG lNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutNLLen(%p, %ld, %d)", pItem, lNumber, iWidth));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
#if HB_INT_MAX == LONG_MAX
if( iWidth <= 0 || iWidth > 99 )
iWidth = HB_INT_LENGTH( lNumber );
pItem->type = HB_IT_INTEGER;
pItem->item.asInteger.value = (int) lNumber;
pItem->item.asInteger.length = iWidth;
#else
if( iWidth <= 0 || iWidth > 99 )
iWidth = HB_LONG_LENGTH( lNumber );
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = (HB_LONG) lNumber;
pItem->item.asLong.length = iWidth;
#endif
return pItem;
}
| itemapi.c | 1084 |
HB_EXPORT PHB_ITEM | hb_itemPutNLLLen( PHB_ITEM pItem, LONGLONG llNumber, int iWidth )
HB_EXPORT PHB_ITEM hb_itemPutNLLLen( PHB_ITEM pItem, LONGLONG llNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutNLLLen(%p, %" PFLL "d, %d)", pItem, llNumber, iWidth));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
#if HB_LONG_MAX >= LONGLONG_MAX
if( iWidth <= 0 || iWidth > 99 )
iWidth = HB_LONG_LENGTH( llNumber );
pItem->type = HB_IT_LONG;
pItem->item.asLong.value = ( HB_LONG ) llNumber;
pItem->item.asLong.length = iWidth;
#else
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.value = ( double ) llNumber;
if( iWidth <= 0 || iWidth > 99 )
iWidth = HB_LONG_LENGTH( pItem->item.asDouble.value );
pItem->item.asDouble.length = iWidth;
pItem->item.asDouble.decimal = 0;
#endif
return pItem;
}
| itemapi.c | 1116 |
HB_EXPORT PHB_ITEM | hb_itemPutNumType( PHB_ITEM pItem, double dNumber, int iDec, int iType1, int iType2 )
HB_EXPORT PHB_ITEM hb_itemPutNumType( PHB_ITEM pItem, double dNumber, int iDec, int iType1, int iType2 )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutNumType( %p, %lf, %d, %i, %i)", pItem, dNumber, iDec, iType1, iType2));
if( iDec || iType1 & HB_IT_DOUBLE || iType2 & HB_IT_DOUBLE )
{
return hb_itemPutNDDec( pItem, dNumber, iDec );
}
else if( HB_DBL_LIM_INT( dNumber ) )
{
return hb_itemPutNI( pItem, ( int ) dNumber );
}
else if( HB_DBL_LIM_LONG( dNumber ) )
{
#ifdef HB_LONG_LONG_OFF
return hb_itemPutNL( pItem, ( long ) dNumber );
#else
return hb_itemPutNLL( pItem, ( LONGLONG ) dNumber );
#endif
}
else
{
return hb_itemPutND( pItem, dNumber );
}
}
| itemapi.c | 1148 |
HB_EXPORT PHB_ITEM | hb_itemPutPtr( PHB_ITEM pItem, void * pValue )
HB_EXPORT PHB_ITEM hb_itemPutPtr( PHB_ITEM pItem, void * pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutPtr(%p, %p)", pItem, pValue));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_POINTER;
pItem->item.asPointer.value = pValue;
pItem->item.asPointer.collect =
pItem->item.asPointer.single = FALSE;
return pItem;
}
| itemapi.c | 1174 |
HB_EXPORT PHB_ITEM | hb_itemPutPtrGC( PHB_ITEM pItem, void * pValue )
HB_EXPORT PHB_ITEM hb_itemPutPtrGC( PHB_ITEM pItem, void * pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutPtrGC(%p, %p)", pItem, pValue));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_POINTER;
pItem->item.asPointer.value = pValue;
pItem->item.asPointer.collect = TRUE;
pItem->item.asPointer.single = FALSE;
return pItem;
}
| itemapi.c | 1194 |
HB_EXPORT PHB_ITEM | hb_itemPutSymbol( PHB_ITEM pItem, PHB_SYMB pSym )
HB_EXPORT PHB_ITEM hb_itemPutSymbol( PHB_ITEM pItem, PHB_SYMB pSym )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutSymbol(%p,%p)", pItem, pSym));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_SYMBOL;
pItem->item.asSymbol.value = pSym;
pItem->item.asSymbol.stackstate = NULL;
pItem->item.asSymbol.paramcnt =
pItem->item.asSymbol.paramdeclcnt = 0;
return pItem;
}
| itemapi.c | 1214 |
HB_EXPORT VOID | hb_itemGetNLen( PHB_ITEM pItem, int * piWidth, int * piDecimal )
HB_EXPORT void hb_itemGetNLen( PHB_ITEM pItem, int * piWidth, int * piDecimal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemGetNLen(%p, %p, %p)", pItem, piWidth, piDecimal));
if( pItem )
{
if( HB_IS_DOUBLE( pItem ) )
{
if( piWidth ) *piWidth = ( int ) pItem->item.asDouble.length;
if( piDecimal ) *piDecimal = ( int ) pItem->item.asDouble.decimal;
}
else if( HB_IS_INTEGER( pItem ) )
{
if( piWidth ) *piWidth = ( int ) pItem->item.asInteger.length;
if( piDecimal ) *piDecimal = 0;
}
else if( HB_IS_LONG( pItem ) )
{
if( piWidth ) *piWidth = ( int ) pItem->item.asLong.length;
if( piDecimal ) *piDecimal = 0;
}
else
{
if( piWidth ) *piWidth = 0;
if( piDecimal ) *piDecimal = 0;
}
}
}
| itemapi.c | 1235 |
HB_EXPORT ULONG | hb_itemSize( PHB_ITEM pItem )
HB_EXPORT ULONG hb_itemSize( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemSize(%p)", pItem));
if( pItem )
{
if( HB_IS_STRING( pItem ) )
return pItem->item.asString.length;
else if( HB_IS_ARRAY( pItem ) )
return hb_arrayLen( pItem );
else if( HB_IS_HASH( pItem ) )
return hb_hashLen( pItem );
}
return 0;
}
| itemapi.c | 1264 |
HB_EXPORT HB_TYPE | hb_itemType( PHB_ITEM pItem )
HB_EXPORT HB_TYPE hb_itemType( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemType(%p)", pItem));
if( pItem )
return ( HB_TYPE ) HB_ITEM_TYPE( pItem );
else
return HB_IT_NIL;
}
| itemapi.c | 1281 |
HB_EXPORT CHAR * | hb_itemTypeStr( PHB_ITEM pItem )
HB_EXPORT char * hb_itemTypeStr( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemTypeStr(%p)", pItem));
switch( HB_ITEM_TYPE( pItem ) )
{
case HB_IT_ARRAY:
return ( char * ) ( hb_arrayIsObject( pItem ) ? "O" : "A" );
case HB_IT_BLOCK:
return "B";
case HB_IT_DATE:
return "D";
case HB_IT_LOGICAL:
return "L";
case HB_IT_INTEGER:
case HB_IT_LONG:
case HB_IT_DOUBLE:
return "N";
case HB_IT_STRING:
return "C";
case HB_IT_MEMO:
return "M";
case HB_IT_HASH:
return "H";
case HB_IT_POINTER:
return "P";
case HB_IT_SYMBOL:
return "S";
}
return "U";
}
| itemapi.c | 1291 |
HB_EXPORT VOID | hb_itemInit( PHB_ITEM pItem )
HB_EXPORT void hb_itemInit( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemInit(%p)", pItem));
if( pItem )
pItem->type = HB_IT_NIL;
}
| itemapi.c | 1335 |
HB_EXPORT VOID | hb_itemClear( PHB_ITEM pItem )
HB_EXPORT void hb_itemClear( PHB_ITEM pItem )
{
HB_TYPE type;
HB_TRACE(HB_TR_DEBUG, ("hb_itemClear(%p)", pItem));
type = HB_ITEM_TYPERAW( pItem );
pItem->type = HB_IT_NIL;
if( type & HB_IT_STRING )
{
if( pItem->item.asString.allocated )
hb_xRefFree( pItem->item.asString.value );
}
else if( type & HB_IT_ARRAY )
hb_gcRefFree( pItem->item.asArray.value );
else if( type & HB_IT_BLOCK )
hb_gcRefFree( pItem->item.asBlock.value );
else if( type & HB_IT_HASH )
hb_gcRefFree( pItem->item.asHash.value );
else if( type & HB_IT_BYREF )
{
if( type & HB_IT_MEMVAR )
hb_memvarValueDecRef( pItem->item.asMemvar.value );
else if( type & HB_IT_ENUM ) /* FOR EACH control variable */
hb_vmEnumRelease( pItem->item.asEnum.basePtr,
pItem->item.asEnum.valuePtr );
else if( type & HB_IT_EXTREF )
pItem->item.asExtRef.func->clear( pItem->item.asExtRef.value );
else if( pItem->item.asRefer.offset == 0 && pItem->item.asRefer.value >= 0 )
hb_gcRefFree( pItem->item.asRefer.BasePtr.array );
}
else if( type & HB_IT_POINTER )
{
if( pItem->item.asPointer.collect )
hb_gcRefFree( pItem->item.asPointer.value );
}
}
| itemapi.c | 1343 |
HB_EXPORT VOID | hb_itemCopy( PHB_ITEM pDest, PHB_ITEM pSource )
HB_EXPORT void hb_itemCopy( PHB_ITEM pDest, PHB_ITEM pSource )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopy(%p, %p)", pDest, pSource));
if( pDest == pSource )
hb_errInternal( HB_EI_ITEMBADCOPY, NULL, "hb_itemCopy()", NULL );
if( HB_IS_COMPLEX( pDest ) )
hb_itemClear( pDest );
memcpy( pDest, pSource, sizeof( HB_ITEM ) );
pDest->type &= ~HB_IT_DEFAULT;
if( HB_IS_COMPLEX( pSource ) )
{
if( HB_IS_STRING( pSource ) )
{
if( pSource->item.asString.allocated )
hb_xRefInc( pSource->item.asString.value );
}
else if( HB_IS_ARRAY( pSource ) )
hb_gcRefInc( pSource->item.asArray.value );
else if( HB_IS_BLOCK( pSource ) )
hb_gcRefInc( pSource->item.asBlock.value );
else if( HB_IS_HASH( pSource ) )
hb_gcRefInc( pSource->item.asHash.value );
else if( HB_IS_BYREF( pSource ) )
{
if( HB_IS_MEMVAR( pSource ) )
hb_memvarValueIncRef( pSource->item.asMemvar.value );
else if( HB_IS_ENUM( pSource ) ) /* enumerators cannnot be copied */
pDest->type = HB_IT_NIL;
else if( HB_IS_EXTREF( pSource ) )
pSource->item.asExtRef.func->copy( pDest );
else if( pSource->item.asRefer.offset == 0 && pSource->item.asRefer.value >= 0 )
hb_gcRefInc( pSource->item.asRefer.BasePtr.array );
}
else if( HB_IS_POINTER( pSource ) )
{
if( pSource->item.asPointer.collect )
{
if( pSource->item.asPointer.single )
pDest->item.asPointer.collect = FALSE;
else
hb_gcRefInc( pSource->item.asPointer.value );
}
}
}
}
| itemapi.c | 1390 |
VOID | hb_itemCopyToRef( PHB_ITEM pDest, PHB_ITEM pSource )
void hb_itemCopyToRef( PHB_ITEM pDest, PHB_ITEM pSource )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyToRef(%p, %p)", pDest, pSource));
if( HB_IS_BYREF( pDest ) )
{
pDest = hb_itemUnRefWrite( pDest, pSource );
if( !pDest || pDest == pSource )
/* extended reference or pDest is a reference to pSource
- do not copy */
return;
}
if( HB_IS_BYREF( pSource ) )
{
if( hb_itemUnRef( pSource ) == pDest )
/*
* assign will create cyclic reference
* pSource and pDest reference to the same item
* we can simply drop coping
*/
return;
}
if( HB_IS_OBJECT( pDest ) &&
hb_objOperatorCall( HB_OO_OP_ASSIGN, pDest, pDest, pSource, NULL ) )
return;
hb_itemCopy( pDest, pSource );
}
| itemapi.c | 1448 |
VOID | hb_itemCopyFromRef( PHB_ITEM pDest, PHB_ITEM pSource )
void hb_itemCopyFromRef( PHB_ITEM pDest, PHB_ITEM pSource )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyFromRef(%p, %p)", pDest, pSource));
if( HB_IS_BYREF( pSource ) )
{
pSource = hb_itemUnRef( pSource );
if( pDest == pSource )
/* pSource is a reference to pDest - do not copy */
return;
}
hb_itemCopy( pDest, pSource );
}
| itemapi.c | 1481 |
HB_EXPORT VOID | hb_itemMove( PHB_ITEM pDest, PHB_ITEM pSource )
HB_EXPORT void hb_itemMove( PHB_ITEM pDest, PHB_ITEM pSource )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemMove(%p, %p)", pDest, pSource));
if( pDest == pSource )
hb_errInternal( HB_EI_ITEMBADCOPY, NULL, "hb_itemMove()", NULL );
if( HB_IS_COMPLEX( pDest ) )
hb_itemClear( pDest );
memcpy( pDest, pSource, sizeof( HB_ITEM ) );
pDest->type &= ~HB_IT_DEFAULT;
pSource->type = HB_IT_NIL;
}
| itemapi.c | 1496 |
VOID | hb_itemMoveRef( PHB_ITEM pDest, PHB_ITEM pSource )
void hb_itemMoveRef( PHB_ITEM pDest, PHB_ITEM pSource )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemMoveRef(%p, %p)", pDest, pSource));
if( HB_IS_BYREF( pSource ) )
{
if( hb_itemUnRef( pSource ) == ( HB_IS_BYREF( pDest ) ?
hb_itemUnRef( pDest ) : pDest ) )
{
/*
* assign will create cyclic reference
* pSource is a reference to pDest
* we can simply drop coping
*/
hb_itemSetNil( pSource );
return;
}
}
if( HB_IS_COMPLEX( pDest ) )
hb_itemClear( pDest );
memcpy( pDest, pSource, sizeof( HB_ITEM ) );
pDest->type &= ~HB_IT_DEFAULT;
pSource->type = HB_IT_NIL;
}
| itemapi.c | 1517 |
VOID | hb_itemMoveToRef( PHB_ITEM pDest, PHB_ITEM pSource )
void hb_itemMoveToRef( PHB_ITEM pDest, PHB_ITEM pSource )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemMoveToRef(%p, %p)", pDest, pSource));
if( HB_IS_BYREF( pDest ) )
{
pDest = hb_itemUnRefWrite( pDest, pSource );
if( !pDest || pDest == pSource )
{
/* extended reference or pDest is a reference to pSource
- do not copy */
hb_itemSetNil( pSource );
return;
}
}
if( HB_IS_BYREF( pSource ) )
{
if( hb_itemUnRef( pSource ) == pDest )
{
/*
* assign will create cyclic reference
* pSource and pDest reference to the same item
* we can simply drop coping
*/
hb_itemSetNil( pSource );
return;
}
}
if( HB_IS_OBJECT( pDest ) &&
hb_objOperatorCall( HB_OO_OP_ASSIGN, pDest, pDest, pSource, NULL ) )
{
hb_itemSetNil( pSource );
return;
}
if( HB_IS_COMPLEX( pDest ) )
hb_itemClear( pDest );
memcpy( pDest, pSource, sizeof( HB_ITEM ) );
pDest->type &= ~HB_IT_DEFAULT;
pSource->type = HB_IT_NIL;
}
| itemapi.c | 1546 |
VOID | hb_itemMoveFromRef( PHB_ITEM pDest, PHB_ITEM pSource )
void hb_itemMoveFromRef( PHB_ITEM pDest, PHB_ITEM pSource )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyFromRef(%p, %p)", pDest, pSource));
if( HB_IS_BYREF( pSource ) )
{
PHB_ITEM pUnRef = hb_itemUnRef( pSource );
if( pDest != pUnRef )
/* pSource is not a reference to pDest - make copy */
hb_itemCopy( pDest, pUnRef );
hb_itemClear( pSource );
}
else
hb_itemMove( pDest, pSource );
}
| itemapi.c | 1591 |
HB_EXPORT VOID | hb_itemSwap( PHB_ITEM pItem1, PHB_ITEM pItem2 )
HB_EXPORT void hb_itemSwap( PHB_ITEM pItem1, PHB_ITEM pItem2 )
{
HB_ITEM temp;
HB_TRACE(HB_TR_DEBUG, ("hb_itemSwap(%p, %p)", pItem1, pItem2));
/*
* It's safe to use this version because our GC cannot be
* activated inside memcpy()
*/
memcpy( &temp, pItem2, sizeof( HB_ITEM ) );
memcpy( pItem2, pItem1, sizeof( HB_ITEM ) );
memcpy( pItem1, &temp, sizeof( HB_ITEM ) );
pItem1->type &= ~HB_IT_DEFAULT;
pItem2->type &= ~HB_IT_DEFAULT;
}
/* Internal API, not standard Clipper */
| itemapi.c | 1609 |
PHB_ITEM | hb_itemUnRefOnce( PHB_ITEM pItem )
PHB_ITEM hb_itemUnRefOnce( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemUnRefOnce(%p)", pItem));
if( HB_IS_BYREF( pItem ) )
{
if( HB_IS_MEMVAR( pItem ) )
{
HB_VALUE_PTR pValue;
pValue = *( pItem->item.asMemvar.itemsbase ) +
pItem->item.asMemvar.value;
pItem = pValue->pVarItem;
}
else if( HB_IS_ENUM( pItem ) ) /* FOR EACH control variable */
{
/* enumerator variable */
if( pItem->item.asEnum.valuePtr )
return pItem->item.asEnum.valuePtr;
else
{
PHB_ITEM pBase = HB_IS_BYREF( pItem->item.asEnum.basePtr ) ?
hb_itemUnRef( pItem->item.asEnum.basePtr ) :
pItem->item.asEnum.basePtr;
if( HB_IS_ARRAY( pBase ) )
{
pBase = hb_arrayGetItemPtr( pBase, pItem->item.asEnum.offset );
if( pBase )
return pBase;
}
else if( HB_IS_HASH( pBase ) )
{
pBase = hb_hashGetValueAt( pBase, pItem->item.asEnum.offset );
if( pBase )
return pBase;
}
else if( HB_IS_STRING( pBase ) )
{
if( pItem->item.asEnum.offset > 0 &&
( ULONG ) pItem->item.asEnum.offset <= pBase->item.asString.length )
{
pItem->item.asEnum.valuePtr = hb_itemPutCL( NULL,
pBase->item.asString.value + pItem->item.asEnum.offset - 1, 1 );
return pItem->item.asEnum.valuePtr;
}
}
/* put it here to avoid recursive RT error generation */
pItem->item.asEnum.valuePtr = hb_itemNew( NULL );
if( hb_vmRequestQuery() == 0 )
{
hb_itemPutNInt( hb_stackAllocItem(), pItem->item.asEnum.offset );
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ),
2, pItem->item.asEnum.basePtr, hb_stackItemFromTop( -1 ) );
hb_stackPop();
}
return pItem->item.asEnum.valuePtr;
}
}
else if( HB_IS_EXTREF( pItem ) )
{
pItem = pItem->item.asExtRef.func->read( pItem );
}
else
{
if( pItem->item.asRefer.value >= 0 )
{
if( pItem->item.asRefer.offset == 0 )
{
/* a reference to a static variable or array item */
if( ( ULONG ) pItem->item.asRefer.value <
pItem->item.asRefer.BasePtr.array->ulLen )
{
pItem = pItem->item.asRefer.BasePtr.array->pItems +
pItem->item.asRefer.value;
}
else if( hb_vmRequestQuery() == 0 )
{
hb_arrayPushBase( pItem->item.asRefer.BasePtr.array );
hb_itemPutNInt( hb_stackAllocItem(), pItem->item.asRefer.value + 1 );
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ),
2, hb_stackItemFromTop( -2 ), hb_stackItemFromTop( -1 ) );
hb_stackPop();
hb_stackPop();
/* check it again - user error handler can resize the array */
if( ( ULONG ) pItem->item.asRefer.value <
pItem->item.asRefer.BasePtr.array->ulLen )
{
pItem = pItem->item.asRefer.BasePtr.array->pItems +
pItem->item.asRefer.value;
}
else
/* It's safe to clear the item - if we are here then
the reference chain to this item does not start in
one of the pItem->item.asRefer.BasePtr.array items
or more then one reference to this array exists
so it will not be freed [druzus] */
hb_itemClear( pItem );
}
}
else
{
/* a reference to a local variable */
HB_ITEM_PTR *pLocal;
pLocal = *( pItem->item.asRefer.BasePtr.itemsbasePtr ) +
pItem->item.asRefer.offset + pItem->item.asRefer.value;
pItem = *pLocal;
}
}
else
{
/* local variable referenced in a codeblock */
pItem = hb_codeblockGetRef( pItem->item.asRefer.BasePtr.block,
pItem->item.asRefer.value );
}
}
}
return pItem;
}
/* Internal API, not standard Clipper */
| itemapi.c | 1629 |
PHB_ITEM | hb_itemUnRef( PHB_ITEM pItem )
PHB_ITEM hb_itemUnRef( PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemUnRef(%p)", pItem));
do
{
pItem = hb_itemUnRefOnce( pItem );
}
while( HB_IS_BYREF( pItem ) );
return pItem;
}
| itemapi.c | 1756 |
PHB_ITEM | hb_itemUnRefWrite( PHB_ITEM pItem, PHB_ITEM pSource )
PHB_ITEM hb_itemUnRefWrite( PHB_ITEM pItem, PHB_ITEM pSource )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemUnRefWrite(%p,%p)", pItem, pSource));
if( HB_IS_EXTREF( pItem ) )
{
pItem = pItem->item.asExtRef.func->write( pItem, pSource );
}
else if( HB_IS_STRING( pSource ) &&
pSource->item.asString.length == 1 )
{
do
{
if( HB_IS_ENUM( pItem ) && HB_IS_BYREF( pItem->item.asEnum.basePtr ) &&
pItem->item.asEnum.offset >= 1 )
{
PHB_ITEM pBase = hb_itemUnRef( pItem->item.asEnum.basePtr );
if( HB_IS_STRING( pBase ) &&
( ULONG ) pItem->item.asEnum.offset <= pBase->item.asString.length )
{
hb_itemUnShareString( pBase );
pBase->item.asString.value[ pItem->item.asEnum.offset - 1 ] =
pSource->item.asString.value[ 0 ];
return pItem->item.asEnum.valuePtr;
}
}
pItem = hb_itemUnRefOnce( pItem );
}
while( HB_IS_BYREF( pItem ) );
}
else
pItem = hb_itemUnRef( pItem );
return pItem;
}
| itemapi.c | 1769 |
PHB_ITEM | hb_itemUnRefRefer( PHB_ITEM pItem )
PHB_ITEM hb_itemUnRefRefer( PHB_ITEM pItem )
{
PHB_ITEM pLast;
HB_TRACE(HB_TR_DEBUG, ("hb_itemUnRefRefer(%p)", pItem));
do
{
pLast = pItem;
pItem = hb_itemUnRefOnce( pItem );
}
while( HB_IS_BYREF( pItem ) );
return pLast;
}
/* Internal API, not standard Clipper */
| itemapi.c | 1808 |
PHB_ITEM | hb_itemReSizeString( PHB_ITEM pItem, ULONG ulSize )
PHB_ITEM hb_itemReSizeString( PHB_ITEM pItem, ULONG ulSize )
{
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_itemReSizeString(%p,%lu)", pItem, ulSize));
if( pItem->item.asString.allocated == 0 )
{
char *szText = ( char* ) hb_xgrab( ulSize + 1 );
hb_xmemcpy( szText, pItem->item.asString.value,
pItem->item.asString.length );
szText[ ulSize ] = '\0';
pItem->item.asString.value = szText;
pItem->item.asString.length = ulSize;
pItem->item.asString.allocated = ulSize + 1;
}
else
{
ULONG ulAlloc = ulSize + 1 +
( pItem->item.asString.allocated < ulSize ? ulSize : 0 );
pItem->item.asString.value = ( char* )
hb_xRefResize( pItem->item.asString.value,
pItem->item.asString.length,
ulAlloc );
pItem->item.asString.length = ulSize;
pItem->item.asString.allocated = ulAlloc;
pItem->item.asString.value[ ulSize ] = '\0';
}
pItem->type &= ~HB_IT_DEFAULT;
return pItem;
}
/* Internal API, not standard Clipper */
| itemapi.c | 1830 |
PHB_ITEM | hb_itemUnShareString( PHB_ITEM pItem )
PHB_ITEM hb_itemUnShareString( PHB_ITEM pItem )
{
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_itemUnShareString(%p)", pItem));
if( pItem->item.asString.allocated == 0 ||
hb_xRefCount( pItem->item.asString.value ) > 1 )
{
ULONG ulLen = pItem->item.asString.length + 1;
char *szText = ( char* ) hb_xgrab( ulLen );
hb_xmemcpy( szText, pItem->item.asString.value, ulLen );
if( pItem->item.asString.allocated )
hb_xRefDec( pItem->item.asString.value );
pItem->item.asString.value = szText;
pItem->item.asString.allocated = ulLen;
}
pItem->type &= ~HB_IT_DEFAULT;
return pItem;
}
| itemapi.c | 1864 |
PHB_ITEM | hb_itemUnShare( PHB_ITEM pItem )
PHB_ITEM hb_itemUnShare( PHB_ITEM pItem )
{
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_itemUnShare(%p)", pItem));
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
if( HB_IS_STRING( pItem ) )
return hb_itemUnShareString( pItem );
else
return pItem;
}
| itemapi.c | 1885 |
HB_EXPORT PHB_ITEM | hb_itemClone( PHB_ITEM pItem )
/* clone the given item */
HB_EXPORT PHB_ITEM hb_itemClone( PHB_ITEM pItem )
{
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_itemClone(%p)", pItem));
if( HB_IS_ARRAY( pItem ) )
{
return hb_arrayClone( pItem );
}
else if( HB_IS_HASH( pItem ) )
{
return hb_hashClone( pItem );
}
else
{
return hb_itemNew( pItem );
}
}
| itemapi.c | 1898 |
HB_EXPORT INT | hb_itemStrCmp( PHB_ITEM pFirst, PHB_ITEM pSecond, BOOL bForceExact )
HB_EXPORT int hb_itemStrCmp( PHB_ITEM pFirst, PHB_ITEM pSecond, BOOL bForceExact )
{
char * szFirst;
char * szSecond;
ULONG ulLenFirst;
ULONG ulLenSecond;
ULONG ulMinLen;
int iRet = 0; /* Current status */
HB_TRACE(HB_TR_DEBUG, ("hb_itemStrCmp(%p, %p, %d)", pFirst, pSecond, (int) bForceExact));
szFirst = pFirst->item.asString.value;
szSecond = pSecond->item.asString.value;
ulLenFirst = pFirst->item.asString.length;
ulLenSecond = pSecond->item.asString.length;
if( hb_set.HB_SET_EXACT && !bForceExact )
{
/* SET EXACT ON and not using == */
/* Don't include trailing spaces */
while( ulLenFirst > ulLenSecond && szFirst[ ulLenFirst - 1 ] == ' ' )
ulLenFirst--;
while( ulLenSecond > ulLenFirst && szSecond[ ulLenSecond - 1 ] == ' ' )
ulLenSecond--;
}
ulMinLen = ulLenFirst < ulLenSecond ? ulLenFirst : ulLenSecond;
/* Both strings not empty */
if( ulMinLen )
{
#ifndef HB_CDP_SUPPORT_OFF
if( hb_cdp_page->lSort )
iRet = hb_cdpcmp( szFirst, ulLenFirst, szSecond, ulLenSecond,
hb_cdp_page, hb_set.HB_SET_EXACT || bForceExact );
else
#endif
{
do
{
if( *szFirst != *szSecond )
{
iRet = ( ( UCHAR ) *szFirst < ( UCHAR ) *szSecond ) ? -1 : 1;
break;
}
szFirst++;
szSecond++;
}
while( --ulMinLen );
/* If equal and length is different ! */
if( !iRet && ulLenFirst != ulLenSecond )
{
/* Force an exact comparison? */
if( hb_set.HB_SET_EXACT || bForceExact || ulLenSecond > ulLenFirst )
iRet = ( ulLenFirst < ulLenSecond ) ? -1 : 1;
}
}
}
else
{
/* Both empty ? */
if( ulLenFirst != ulLenSecond )
{
if( hb_set.HB_SET_EXACT || bForceExact )
iRet = ( ulLenFirst < ulLenSecond ) ? -1 : 1;
else
iRet = ( ulLenSecond == 0 ) ? 0 : -1;
}
else
/* Both empty => Equal ! */
iRet = 0;
}
return iRet;
}
| itemapi.c | 1921 |
HB_EXPORT INT | hb_itemStrICmp( PHB_ITEM pFirst, PHB_ITEM pSecond, BOOL bForceExact )
HB_EXPORT int hb_itemStrICmp( PHB_ITEM pFirst, PHB_ITEM pSecond, BOOL bForceExact )
{
char * szFirst;
char * szSecond;
ULONG ulLenFirst;
ULONG ulLenSecond;
ULONG ulMinLen;
int iRet = 0; /* Current status */
HB_TRACE(HB_TR_DEBUG, ("hb_itemStrICmp(%p, %p, %d)", pFirst, pSecond, (int) bForceExact));
szFirst = pFirst->item.asString.value;
szSecond = pSecond->item.asString.value;
ulLenFirst = pFirst->item.asString.length;
ulLenSecond = pSecond->item.asString.length;
if( hb_set.HB_SET_EXACT && !bForceExact )
{
/* SET EXACT ON and not using == */
/* Don't include trailing spaces */
while( ulLenFirst > ulLenSecond && szFirst[ ulLenFirst - 1 ] == ' ' )
ulLenFirst--;
while( ulLenSecond > ulLenFirst && szSecond[ ulLenSecond - 1 ] == ' ' )
ulLenSecond--;
}
ulMinLen = ulLenFirst < ulLenSecond ? ulLenFirst : ulLenSecond;
/* Both strings not empty */
if( ulMinLen )
{
#ifndef HB_CDP_SUPPORT_OFF
if( hb_cdp_page->lSort )
iRet = hb_cdpicmp( szFirst, ulLenFirst, szSecond, ulLenSecond,
hb_cdp_page, hb_set.HB_SET_EXACT || bForceExact );
else
#endif
{
do
{
int i1 = toupper( ( UCHAR ) *szFirst );
int i2 = toupper( ( UCHAR ) *szSecond );
if( i1 != i2 )
{
iRet = ( i1 < i2 ) ? -1 : 1;
break;
}
szFirst++;
szSecond++;
}
while( --ulMinLen );
/* If equal and length is different ! */
if( !iRet && ulLenFirst != ulLenSecond )
{
/* Force an exact comparison? */
if( hb_set.HB_SET_EXACT || bForceExact || ulLenSecond > ulLenFirst )
iRet = ( ulLenFirst < ulLenSecond ) ? -1 : 1;
}
}
}
else
{
/* Both empty ? */
if( ulLenFirst != ulLenSecond )
{
if( hb_set.HB_SET_EXACT || bForceExact )
iRet = ( ulLenFirst < ulLenSecond ) ? -1 : 1;
else
iRet = ( ulLenSecond == 0 ) ? 0 : -1;
}
else
/* Both empty => Equal ! */
iRet = 0;
}
return iRet;
}
| itemapi.c | 1999 |
HB_EXPORT BOOL | hb_itemStrBuf( char *szResult, PHB_ITEM pNumber, int iSize, int iDec )
HB_EXPORT BOOL hb_itemStrBuf( char *szResult, PHB_ITEM pNumber, int iSize, int iDec )
{
int iPos, iDot;
BOOL fNeg;
if( iDec < 0 )
{
iDec = 0;
}
if( iDec > 0 )
{
iPos = iDot = iSize - iDec - 1;
}
else
{
iPos = iSize;
iDot = 0;
}
if( HB_IS_DOUBLE( pNumber ) )
{
double dNumber = hb_itemGetND( pNumber );
/* TODO: look if finite()/_finite() or isinf()/_isinf and isnan()/_isnan
does exist for your compiler and add this to the check below */
#if defined(__RSXNT__) || defined(__EMX__) || \
defined(__XCC__) || defined(__POCC__) || \
defined(HB_OS_HPUX)
# define HB_FINITE_DBL(d) ( isfinite(d)!=0 )
#elif defined(__WATCOMC__) || defined(__BORLANDC__) || defined(_MSC_VER)
# define HB_FINITE_DBL(d) ( _finite(d)!=0 )
#elif defined(__GNUC__) || defined(__DJGPP__) || defined(__MINGW32__) || \
defined(__LCC__)
# define HB_FINITE_DBL(d) ( finite(d)!=0 )
#else
/* added infinity check for Borland C [martin vogel] */
/* Borland C 5.5 has _finite() function, if it's necessary
we can reenable this code for older DOS BCC versions
Now this code is for generic C compilers undefined above
[druzus] */
static BOOL s_bInfinityInit = FALSE;
static double s_dInfinity = 0;
if( ! s_bInfinityInit )
{
/* set math handler to NULL for evaluating log(0),
to avoid error messages [martin vogel]*/
HB_MATH_HANDLERPROC fOldMathHandler = hb_mathSetHandler (NULL);
s_dInfinity = -log( ( double ) 0 );
hb_mathSetHandler (fOldMathHandler);
s_bInfinityInit = TRUE;
}
# define HB_FINITE_DBL(d) ( (d) != s_dInfinity && (d) != -s_dInfinity )
#endif
if( pNumber->item.asDouble.length == 99 || !HB_FINITE_DBL( dNumber ) )
{
/* Numeric overflow */
iPos = -1;
}
else
{
double dInt, dFract, dDig, doBase = 10.0;
int iPrec, iFirst = -1;
/* dNumber = hb_numRound( dNumber, iDec ); */
#ifdef HB_NUM_PRECISION
iPrec = HB_NUM_PRECISION;
#else
iPrec = 16;
#endif
if( dNumber < 0 )
{
fNeg = TRUE;
dFract = modf( -dNumber, &dInt );
}
else
{
fNeg = FALSE;
dFract = modf( dNumber, &dInt );
}
while( iPos-- > 0 )
{
dDig = modf( dInt / doBase + 0.01, &dInt ) * doBase;
szResult[ iPos ] = '0' + ( char ) ( dDig + 0.01 );
if( szResult[ iPos ] != '0' )
iFirst = iPos;
if( dInt < 1 )
break;
}
if( iPos > 0 )
{
memset( szResult, ' ', iPos );
}
if( iDec > 0 && iPos >= 0 )
{
for( iPos = iDot + 1; iPos < iSize; iPos++ )
{
dFract = modf( dFract * doBase, &dDig );
szResult[ iPos ] = '0' + ( char ) ( dDig + 0.01 );
if( iFirst < 0 )
{
if( szResult[ iPos ] != '0' )
{
iFirst = iPos - 1;
}
}
else if( iPos - iFirst >= iPrec )
{
break;
}
}
}
/* now try to round the results and set 0 in places over defined
precision, the same is done by Clipper */
if( iPos >= 0 )
{
int iZer, iLast;
if( iFirst < 0 )
{
iZer = 0;
}
else
{
iZer = iSize - iFirst - iPrec - ( iDec > 0 ? 1 : 0 );
}
dFract = modf( dFract * doBase, &dDig );
iLast = ( int ) ( dDig + 0.01 );
/* hack for x.xxxx4999999999, f.e. 8.995 ~FL 8.994999999999999218.. */
if( iLast == 4 && iZer < 0 )
{
for( iPos = -iZer; iPos > 0; --iPos )
{
dFract = modf( dFract * doBase, &dDig );
if( dDig + 0.01 < 9 && ( iPos != 1 || dDig < 2 ) )
break;
}
if( iPos == 0 )
iLast = 5;
}
iLast = iLast >= 5 ? 1 : 0;
iPos = iSize;
while ( iPos-- > 0 )
{
if( iDec == 0 || iPos != iDot )
{
if( iZer > 0 )
{
if( iDec == 0 || iPos <= iDot + 1 )
{
iLast = szResult[ iPos ] >= '5' ? 1 : 0;
}
szResult[ iPos ] = '0';
--iZer;
}
else if( iLast > 0 )
{
if( szResult[ iPos ] == '9' )
{
szResult[ iPos ] = '0';
}
else
{
if( szResult[ iPos ] < '0' ) /* '-' or ' ' */
{
szResult[ iPos ] = '1';
iFirst = iPos;
}
else
{
szResult[ iPos ]++;
if( iFirst < 0 )
{
iFirst = iPos;
}
}
break;
}
}
else
{
break;
}
}
}
if( fNeg && iFirst >= 0 && iPos >= 0 )
{
iPos = ( iDot > 0 && iFirst >= iDot ) ? iDot - 2 : iFirst - 1;
if( iPos >= 0 )
{
szResult[ iPos ] = '-';
}
}
}
}
}
else
{
HB_LONG lNumber;
if( HB_IS_INTEGER( pNumber ) )
lNumber = pNumber->item.asInteger.value;
else if( HB_IS_LONG( pNumber ) )
lNumber = pNumber->item.asLong.value;
else if( HB_IS_DATE( pNumber ) )
lNumber = pNumber->item.asDate.value;
else if( HB_IS_STRING( pNumber ) )
lNumber = pNumber->item.asString.value[0];
else
{
lNumber = 0;
iPos = -1;
}
fNeg = ( lNumber < 0 );
while ( iPos-- > 0 )
{
szResult[ iPos ] = '0' + ( char ) ( fNeg ? -( lNumber % 10 ) : ( lNumber % 10 ) );
lNumber /= 10;
if( lNumber == 0 )
break;
}
if( fNeg && iPos-- > 0 )
szResult[ iPos ] = '-';
if( iPos > 0 )
memset( szResult, ' ', iPos );
if( iDec > 0 && iPos >= 0 )
memset( &szResult[iSize - iDec], '0', iDec );
}
szResult[ iSize ] = '\0';
/* Set to asterisks in case of overflow */
if( iPos < 0 )
{
memset( szResult, '*', iSize );
return FALSE;
}
else if( iDot > 0 )
{
szResult[ iDot ] = '.';
}
return TRUE;
}
/* converts a numeric to a string with optional width & precision.
This function should be used by any function that wants to format numeric
data for displaying, printing, or putting in a database.
| itemapi.c | 2081 |
HB_EXPORT CHAR * | hb_itemStr( PHB_ITEM pNumber, PHB_ITEM pWidth, PHB_ITEM pDec )
Note: The caller is responsible for calling hb_xfree to free the results
buffer, but ONLY if the return value is not a NULL pointer! (If a NULL
pointer is returned, then there was a conversion error.)
*/
HB_EXPORT char * hb_itemStr( PHB_ITEM pNumber, PHB_ITEM pWidth, PHB_ITEM pDec )
{
char * szResult = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_itemStr(%p, %p, %p)", pNumber, pWidth, pDec));
if( pNumber )
{
/* Default to the width and number of decimals specified by the item,
with a limit of 90 integer places, plus one space for the sign. */
int iWidth, iDec, iSize;
hb_itemGetNLen( pNumber, &iWidth, &iDec );
if( iWidth > 90 )
iWidth = 90;
if( pWidth && HB_IS_NUMERIC( pWidth ) )
{
/* If the width parameter is specified, override the default value
and set the number of decimals to zero */
iWidth = hb_itemGetNI( pWidth );
if( iWidth < 1 )
iWidth = 10; /* If 0 or negative, use default */
iDec = 0;
}
/* Clipper ignores decimal places when iWidth is 1 */
if( iWidth > 1 && pDec && HB_IS_NUMERIC( pDec ) )
{
/* This function does not include the decimal places in the width,
so the width must be adjusted downwards, if the decimal places
parameter is greater than 0 */
iDec = hb_itemGetNI( pDec );
if( iDec <= 0 )
iDec = 0;
else if( pWidth )
iWidth -= ( iDec + 1 );
}
iSize = ( iDec > 0 ? iWidth + 1 + iDec : iWidth );
if( iSize > 0 )
{
szResult = ( char * ) hb_xgrab( iSize + 1 );
hb_itemStrBuf( szResult, pNumber, iSize, iDec );
}
}
return szResult;
}
| itemapi.c | 2344 |
HB_EXPORT CHAR * | hb_itemString( PHB_ITEM pItem, ULONG * ulLen, BOOL * bFreeReq )
HB_EXPORT char * hb_itemString( PHB_ITEM pItem, ULONG * ulLen, BOOL * bFreeReq )
{
char * buffer;
HB_TRACE(HB_TR_DEBUG, ("hb_itemString(%p, %p, %p)", pItem, ulLen, bFreeReq));
switch( HB_ITEM_TYPE( pItem ) )
{
case HB_IT_STRING:
case HB_IT_MEMO:
buffer = hb_itemGetCPtr( pItem );
* ulLen = hb_itemGetCLen( pItem );
* bFreeReq = FALSE;
break;
case HB_IT_DATE:
{
char szDate[ 9 ];
hb_dateDecStr( szDate, pItem->item.asDate.value );
buffer = ( char * ) hb_xgrab( 11 );
hb_dateFormat( szDate, buffer, hb_set.HB_SET_DATEFORMAT );
* ulLen = strlen( buffer );
* bFreeReq = TRUE;
}
break;
case HB_IT_DOUBLE:
case HB_IT_INTEGER:
case HB_IT_LONG:
if( hb_set.HB_SET_FIXED )
{
/* If fixed mode is enabled, use the default number of decimal places. */
hb_itemPutNI( hb_stackAllocItem(), hb_set.HB_SET_DECIMALS );
buffer = hb_itemStr( pItem, NULL, hb_stackItemFromTop( -1 ) );
hb_stackPop();
}
else
buffer = hb_itemStr( pItem, NULL, NULL );
if( buffer )
{
* ulLen = strlen( buffer );
* bFreeReq = TRUE;
}
else
{
buffer = "";
* ulLen = 0;
* bFreeReq = FALSE;
}
break;
case HB_IT_NIL:
buffer = "NIL";
* ulLen = 3;
* bFreeReq = FALSE;
break;
case HB_IT_LOGICAL:
buffer = ( char * ) ( hb_itemGetL( pItem ) ? ".T." : ".F." );
* ulLen = 3;
* bFreeReq = FALSE;
break;
case HB_IT_POINTER:
{
int size = ( sizeof( void * ) << 1 ) + 3; /* n bytes for address + 0x + \0 */
int n;
BOOL bFail = TRUE;
buffer = ( char * ) hb_xgrab( size );
do
{
n = snprintf( buffer, size, "%p", hb_itemGetPtr( pItem ) );
if( (n > -1) && (n < size) )
{
bFail = FALSE;
}
else
{
if( n > -1 )
size = n + 1;
else
size *= 2;
buffer = ( char * ) hb_xrealloc( buffer, size );
}
}
while( bFail );
* ulLen = strlen( buffer );
* bFreeReq = TRUE;
break;
}
default:
buffer = "";
* ulLen = 0;
* bFreeReq = FALSE;
}
return buffer;
}
| itemapi.c | 2408 |
HB_EXPORT CHAR * | hb_itemPadConv( PHB_ITEM pItem, ULONG * pulSize, BOOL * bFreeReq )
HB_EXPORT char * hb_itemPadConv( PHB_ITEM pItem, ULONG * pulSize, BOOL * bFreeReq )
{
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_itemPadConv(%p, %p, %p)", pItem, pulSize, bFreeReq));
if( pItem )
{
switch( HB_ITEM_TYPE( pItem ) )
{
case HB_IT_STRING:
case HB_IT_MEMO:
case HB_IT_DATE:
return hb_itemString( pItem, pulSize, bFreeReq );
case HB_IT_DOUBLE:
case HB_IT_INTEGER:
case HB_IT_LONG:
{
int i;
char * buffer = hb_itemString( pItem, pulSize, bFreeReq );
/* remove leading spaces if any, a little bit redundant but
* I don't want to complicate the API interface more. Druzus
*/
for( i = 0; buffer[i] == ' '; i++ );
if( i > 0 )
{
int j = 0;
* pulSize -= i;
do
{
buffer[j++] = buffer[i];
}
while( buffer[i++] );
}
return buffer;
}
default:
break;
}
}
return NULL;
}
| itemapi.c | 2514 |
HB_EXPORT PHB_ITEM | hb_itemValToStr( PHB_ITEM pItem )
HB_EXPORT PHB_ITEM hb_itemValToStr( PHB_ITEM pItem )
{
PHB_ITEM pResult;
char * buffer;
ULONG ulLen;
BOOL bFreeReq;
HB_TRACE(HB_TR_DEBUG, ("hb_itemValToStr(%p)", pItem));
buffer = hb_itemString( pItem, &ulLen, &bFreeReq );
if( bFreeReq )
pResult = hb_itemPutCLPtr( NULL, buffer, ulLen );
else
pResult = hb_itemPutCL( NULL, buffer, ulLen );
return pResult;
}
| itemapi.c | 2558 |
macro.c |
Type | Function | Source | Line |
STATIC INT | hb_macroParse( HB_MACRO_PTR pMacro )
static int hb_macroParse( HB_MACRO_PTR pMacro )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroParse(%p)", pMacro));
/* initialize the output (pcode) buffer - it will be filled by yacc */
pMacro->pCodeInfo = (HB_PCODE_INFO_PTR ) hb_xgrab( sizeof( HB_PCODE_INFO ) );
pMacro->pCodeInfo->lPCodeSize = HB_PCODE_SIZE;
pMacro->pCodeInfo->lPCodePos = 0;
pMacro->pCodeInfo->fVParams = FALSE;
pMacro->pCodeInfo->pLocals = NULL;
pMacro->pCodeInfo->pPrev = NULL;
pMacro->pCodeInfo->pCode = ( BYTE * ) hb_xgrab( HB_PCODE_SIZE );
/* reset the type of compiled expression - this should be filled after
* successfully compilation
*/
pMacro->pError = NULL;
pMacro->uiListElements = 0;
pMacro->exprType = HB_ET_NONE;
return hb_macroYYParse( pMacro );
}
| macro.c | 71 |
VOID | hb_macroDelete( HB_MACRO_PTR pMacro )
void hb_macroDelete( HB_MACRO_PTR pMacro )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroDelete(%p)", pMacro));
hb_xfree( (void *) pMacro->pCodeInfo->pCode );
hb_xfree( (void *) pMacro->pCodeInfo );
if( pMacro->pError )
hb_errRelease( pMacro->pError );
if( pMacro->Flags & HB_MACRO_DEALLOCATE )
hb_xfree( pMacro );
}
| macro.c | 102 |
STATIC BOOL | hb_macroCheckParam( HB_ITEM_PTR pItem )
static BOOL hb_macroCheckParam( HB_ITEM_PTR pItem )
{
BOOL bValid = TRUE;
HB_TRACE(HB_TR_DEBUG, ("hb_macroCheckParam(%p)", pItem));
if( ! HB_IS_STRING( pItem ) )
{
HB_ITEM_PTR pResult = hb_errRT_BASE_Subst( EG_ARG, 1065, NULL, "&", 1, pItem );
bValid = FALSE;
if( pResult )
{
hb_stackPop();
hb_vmPush( pResult );
hb_itemRelease( pResult );
}
}
return bValid;
}
| macro.c | 120 |
STATIC HB_ERROR_HANDLE( | hb_macroErrorType )
static HB_ERROR_HANDLE( hb_macroErrorType )
{
HB_MACRO_PTR pMacro = ( HB_MACRO_PTR ) ErrorInfo->Cargo;
/* copy error object for later diagnostic usage */
if( !pMacro->pError )
pMacro->pError = hb_itemNew( ErrorInfo->Error );
pMacro->status &= ~HB_MACRO_CONT;
/* ignore rest of compiled code */
hb_vmRequestEndProc();
return NULL; /* ignore this error */
}
| macro.c | 143 |
VOID | hb_macroRun( HB_MACRO_PTR pMacro )
void hb_macroRun( HB_MACRO_PTR pMacro )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroRun(%p)", pMacro));
hb_vmExecute( pMacro->pCodeInfo->pCode, NULL );
}
| macro.c | 162 |
STATIC VOID | hb_macroSyntaxError( HB_MACRO_PTR pMacro )
static void hb_macroSyntaxError( HB_MACRO_PTR pMacro )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroSyntaxError(%p)", pMacro));
if( pMacro && pMacro->pError )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroSyntaxError.(%s)", pMacro->string));
hb_stackPop(); /* remove compiled string */
hb_errLaunch( pMacro->pError );
hb_errRelease( pMacro->pError );
pMacro->pError = NULL;
}
else
{
PHB_ITEM pResult = hb_errRT_BASE_Subst( EG_SYNTAX, 1449, NULL, "&", 1, hb_stackItemFromTop( -1 ) );
if( pResult )
{
hb_stackPop(); /* remove compiled string */
hb_vmPush( pResult );
hb_itemRelease( pResult );
}
}
}
| macro.c | 174 |
STATIC CHAR * | hb_macroTextSubst( char * szString, ULONG *pulStringLen )
static char * hb_macroTextSubst( char * szString, ULONG *pulStringLen )
{
char * szResult;
ULONG ulResStrLen;
ULONG ulResBufLen;
ULONG ulCharsLeft;
char * pHead;
char * pTail;
HB_TRACE(HB_TR_DEBUG, ("hb_macroTextSubst(%s, %li)", szString, *pulStringLen));
pHead = (char *) memchr( (void *) szString, '&', *pulStringLen );
if( pHead == NULL )
return szString; /* no more processing is required */
/* initial length of the string and the result buffer (it can contain null bytes) */
ulResBufLen = ulResStrLen = *pulStringLen;
/* initial buffer for return value */
szResult = (char *) hb_xgrab( ulResBufLen + 1 );
/* copy the input string with trailing zero byte
*/
memcpy( szResult, szString, ulResStrLen + 1 );
/* switch the pointer so it will point into the result buffer
*/
pHead = szResult + ( pHead - szString );
do
{
/* store the position where '&' was found so we can restart scanning
* from this point after macro expansion
*/
pTail = pHead;
/* check if the next character can start a valid identifier
* (only _a-zA-Z are allowed)
*/
++pHead; /* skip '&' character */
if( *pHead == '_' ||
( *pHead >= 'A' && *pHead <= 'Z' ) ||
( *pHead >= 'a' && *pHead <= 'z' ) )
{
/* extract a variable name */
/* NOTE: the extracted name can be longer then supported maximal
* length of identifiers (HB_SYMBOL_NAME_LEN) - only the max allowed
* are used for name lookup however the whole string is replaced
*/
ULONG ulNameLen = 1;
char * pName = pHead;
while( *++pHead && ( *pHead == '_' ||
( *pHead >= 'A' && *pHead <= 'Z' ) ||
( *pHead >= 'a' && *pHead <= 'z' ) ||
( *pHead >= '0' && *pHead <= '9' ) ) )
{
++ulNameLen;
}
/* pHead points now at the character that terminated a variable name */
/* NOTE: '_' is invalid variable name
*/
if( ulNameLen > 1 || *pName != '_' )
{
/* this is not the "&_" string */
char * szValPtr;
ULONG ulValLen;
/* Get a pointer to the string value stored in this variable
* or NULL if variable doesn't exist or doesn't contain a string
* value.
* NOTE: This doesn't create a copy of the value then it
* shouldn't be released here.
*/
ulValLen = ulNameLen; /* the length of name */
szValPtr = hb_memvarGetStrValuePtr( pName, &ulValLen );
if( szValPtr )
{
if( *pHead == '.' )
{
/* we have stopped at the macro terminator '.' - skip it */
++pHead;
++ulNameLen;
}
++ulNameLen; /* count also the '&' character */
/* number of characters left on the right side of a variable name */
ulCharsLeft = ulResStrLen - ( pHead - szResult );
/* NOTE:
* if a replacement string is shorter then the variable
* name then we don't have to reallocate the result buffer:
* 'ulResStrLen' stores the current length of a string in the buffer
* 'ulResBufLen' stores the length of the buffer
*/
if( ulValLen > ulNameLen )
{
ulResStrLen += ( ulValLen - ulNameLen );
if( ulResStrLen > ulResBufLen )
{
ULONG ulHead = pHead - szResult;
ULONG ulTail = pTail - szResult;
ulResBufLen = ulResStrLen;
szResult = ( char * ) hb_xrealloc( szResult, ulResBufLen + 1 );
pHead = szResult + ulHead;
pTail = szResult + ulTail;
}
}
else
ulResStrLen -= ( ulNameLen - ulValLen );
/* move bytes located on the right side of a variable name */
memmove( pTail + ulValLen, pHead, ulCharsLeft + 1 );
/* copy substituted value */
memcpy( pTail, szValPtr, ulValLen );
/* restart scanning from the beginning of replaced string */
/* NOTE: This causes that the following code:
* a := '&a'
* var := '&a.b'
* is the same as:
* var := '&ab'
*/
pHead = pTail;
}
}
}
ulCharsLeft = ulResStrLen - ( pHead - szResult );
}
while( ulCharsLeft && ( pHead = (char *) memchr( (void *)pHead, '&', ulCharsLeft ) ) != NULL );
if( ulResStrLen < ulResBufLen )
{
/* result string is shorter then allocated buffer -
* cut it to a required length
*/
szResult = ( char * ) hb_xrealloc( szResult, ulResStrLen + 1 );
}
szResult[ ulResStrLen ] = 0; /* place terminating null character */
/* return a length of result string */
*pulStringLen = ulResStrLen;
return szResult; /* a new memory buffer was allocated */
}
| macro.c | 201 |
VOID | hb_macroGetValue( HB_ITEM_PTR pItem, BYTE iContext, BYTE flags )
void hb_macroGetValue( HB_ITEM_PTR pItem, BYTE iContext, BYTE flags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroGetValue(%p)", pItem));
if( hb_macroCheckParam( pItem ) )
{
HB_MACRO struMacro;
int iStatus;
BOOL fFree;
struMacro.mode = HB_MODE_MACRO;
struMacro.supported = (flags & HB_SM_RT_MACRO) ? s_macroFlags : flags;
struMacro.Flags = HB_MACRO_GEN_PUSH;
struMacro.uiNameLen = HB_SYMBOL_NAME_LEN;
struMacro.status = HB_MACRO_CONT;
struMacro.length = pItem->item.asString.length;
/*
* Clipper appears to expand nested macros staticly vs. by
* Macro Parser, f.e.:
* PROCEDURE Main()
* LOCAL cText
* cText := "( v := 'A' ) + &v"
* M->v := "'B'"
* ? "Macro:", cText
* ? "Result:", &cText
* ? "Type:", type(cText)
* RETURN
*/
struMacro.string = hb_macroTextSubst( pItem->item.asString.value, &struMacro.length );
fFree = struMacro.string != pItem->item.asString.value;
if( iContext != 0 )
{
/*
* If compiled in xbase compatibility mode:
* macro := "1,2"
* funCall( ¯o ) ==> funCall( 1, 2 )
* { ¯o } ==> { 1, 2 }
* var[ ¯o ] ==> var[ 1, 2 ]
* var := (somevalue, ¯o) ==> var := 2
*
* Always:
* macro := "1,2"
* EVAL( {|| ¯o} )
*
*/
struMacro.Flags |= HB_MACRO_GEN_LIST;
if( iContext == HB_P_MACROPUSHPARE )
{
struMacro.Flags |= HB_MACRO_GEN_PARE;
}
}
iStatus = hb_macroParse( &struMacro );
if( iStatus == HB_MACRO_OK && ( struMacro.status & HB_MACRO_CONT ) )
{
hb_stackPop(); /* remove compiled string */
hb_macroRun( &struMacro );
if( iContext == HB_P_MACROPUSHLIST )
hb_vmPushLong( struMacro.uiListElements + 1 );
}
else
hb_macroSyntaxError( &struMacro );
if( fFree )
hb_xfree( struMacro.string );
hb_macroDelete( &struMacro );
}
else if( iContext == HB_P_MACROPUSHLIST && hb_vmRequestQuery() == 0 )
{
hb_vmPushInteger( 1 );
}
}
| macro.c | 382 |
VOID | hb_macroSetValue( HB_ITEM_PTR pItem, BYTE flags )
void hb_macroSetValue( HB_ITEM_PTR pItem, BYTE flags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroSetValue(%p)", pItem));
if( hb_macroCheckParam( pItem ) )
{
HB_MACRO struMacro;
int iStatus;
struMacro.mode = HB_MODE_MACRO;
struMacro.supported = (flags & HB_SM_RT_MACRO) ? s_macroFlags : flags;
struMacro.Flags = HB_MACRO_GEN_POP;
struMacro.uiNameLen = HB_SYMBOL_NAME_LEN;
struMacro.status = HB_MACRO_CONT;
struMacro.string = pItem->item.asString.value;
struMacro.length = pItem->item.asString.length;
iStatus = hb_macroParse( &struMacro );
if( iStatus == HB_MACRO_OK && ( struMacro.status & HB_MACRO_CONT ) )
{
hb_stackPop(); /* remove compiled string */
hb_macroRun( &struMacro );
}
else
hb_macroSyntaxError( &struMacro );
hb_macroDelete( &struMacro );
}
else if( hb_vmRequestQuery() == 0 )
{
hb_stackPop();
hb_stackPop();
}
}
| macro.c | 459 |
STATIC VOID | hb_macroUseAliased( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, int iFlag, BYTE bSupported )
static void hb_macroUseAliased( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, int iFlag, BYTE bSupported )
{
if( HB_IS_STRING( pAlias ) && HB_IS_STRING( pVar ) )
{
/* grab memory for "alias->var"
*/
ULONG ulLen = pAlias->item.asString.length + pVar->item.asString.length + 2;
char * szString = ( char * ) hb_xgrab( ulLen + 1 );
HB_MACRO struMacro;
int iStatus;
memcpy( szString, pAlias->item.asString.value, pAlias->item.asString.length );
szString[ pAlias->item.asString.length ] = '-';
szString[ pAlias->item.asString.length + 1 ] = '>';
memcpy( szString + pAlias->item.asString.length + 2, pVar->item.asString.value, pVar->item.asString.length );
szString[ ulLen ] = '\0';
struMacro.mode = HB_MODE_MACRO;
struMacro.supported = (bSupported & HB_SM_RT_MACRO) ? s_macroFlags : bSupported;
struMacro.Flags = iFlag;
struMacro.uiNameLen = HB_SYMBOL_NAME_LEN;
struMacro.status = HB_MACRO_CONT;
struMacro.string = szString;
struMacro.length = ulLen;
iStatus = hb_macroParse( &struMacro );
hb_stackPop(); /* remove compiled variable name */
hb_stackPop(); /* remove compiled alias */
if( iStatus == HB_MACRO_OK && ( struMacro.status & HB_MACRO_CONT ) )
{
hb_macroRun( &struMacro );
}
else
{
hb_vmPushString( szString, ulLen );
hb_macroSyntaxError( &struMacro );
}
hb_xfree( szString );
hb_macroDelete( &struMacro );
}
else if( hb_macroCheckParam( pVar ) )
{
/* only right side of alias operator is a string - macro-compile
* this part only
*/
HB_MACRO struMacro;
int iStatus;
struMacro.mode = HB_MODE_MACRO;
struMacro.supported = (bSupported & HB_SM_RT_MACRO) ? s_macroFlags : bSupported;
struMacro.Flags = iFlag | HB_MACRO_GEN_ALIASED;
struMacro.uiNameLen = HB_SYMBOL_NAME_LEN;
struMacro.status = HB_MACRO_CONT;
struMacro.string = pVar->item.asString.value;
struMacro.length = pVar->item.asString.length;
iStatus = hb_macroParse( &struMacro );
if( iStatus == HB_MACRO_OK && ( struMacro.status & HB_MACRO_CONT ) )
{
hb_stackPop(); /* remove compiled string */
hb_macroRun( &struMacro );
}
else
hb_macroSyntaxError( &struMacro );
hb_macroDelete( &struMacro );
}
}
| macro.c | 500 |
VOID | hb_macroPopAliasedValue( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, BYTE flags )
void hb_macroPopAliasedValue( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, BYTE flags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroPopAliasedValue(%p, %p)", pAlias, pVar));
hb_macroUseAliased( pAlias, pVar, HB_MACRO_GEN_POP, flags );
}
| macro.c | 587 |
VOID | hb_macroPushAliasedValue( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, BYTE flags )
void hb_macroPushAliasedValue( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, BYTE flags )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroPushAliasedValue(%p, %p)", pAlias, pVar));
hb_macroUseAliased( pAlias, pVar, HB_MACRO_GEN_PUSH, flags );
}
| macro.c | 599 |
CHAR * | hb_macroExpandString( char *szString, ULONG ulLength, BOOL *pfNewString )
char * hb_macroExpandString( char *szString, ULONG ulLength, BOOL *pfNewString )
{
char *szResultString;
HB_TRACE(HB_TR_DEBUG, ("hb_macroExpandString(%s,%lu,%p)", szString, ulLength, pfNewString));
if( szString )
szResultString = hb_macroTextSubst( szString, &ulLength );
else
szResultString = szString;
*pfNewString = ( szString != szResultString );
return szResultString;
}
| macro.c | 611 |
CHAR * | hb_macroTextSymbol( char *szString, ULONG ulLength, BOOL *pfNewString )
char * hb_macroTextSymbol( char *szString, ULONG ulLength, BOOL *pfNewString )
{
char *szResult = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_macroTextSymbol(%s,%lu,%p)", szString, ulLength, pfNewString));
if( szString )
{
ULONG ulLen = 0;
szResult = hb_macroTextSubst( szString, &ulLength );
while( ulLength && ( szResult[ 0 ] == ' ' || szResult[ 0 ] == '\t' ) )
{
++szResult;
++szString;
--ulLength;
}
while( ulLength && ( szResult[ ulLength - 1 ] == ' ' ||
szResult[ ulLength - 1 ] == '\t' ) )
--ulLength;
/* NOTE: This uses _a-zA-Z0-9 pattern to check for a valid name
* "_" is not valid macro string
*/
while( ulLen < ulLength )
{
char c = szResult[ ulLen ];
if( c >= 'a' && c <= 'z' )
{
if( szResult == szString )
{
szResult = ( char * ) hb_xgrab( ulLength + 1 );
memcpy( szResult, szString, ulLength );
szResult[ ulLength ] = '\0';
}
szResult[ ulLen ] = c - ( 'a' - 'A' );
}
else if( ! ( c == '_' || ( c >= 'A' && c <= 'Z' ) ||
( ulLen && ( c >= '0' && c <= '9' ) ) ) )
{
break;
}
++ulLen;
}
if( ulLen == ulLength && ulLen > ( ULONG ) ( szResult[ 0 ] == '_' ? 1 : 0 ) )
{
if( ulLen > HB_SYMBOL_NAME_LEN )
ulLen = HB_SYMBOL_NAME_LEN;
if( szResult[ ulLen ] )
{
if( szResult == szString )
{
szResult = ( char * ) hb_xgrab( ulLen + 1 );
memcpy( szResult, szString, ulLen );
}
szResult[ ulLen ] = '\0';
}
}
else
{
if( szResult != szString )
hb_xfree( szResult );
szResult = NULL;
}
}
*pfNewString = szResult && szString != szResult;
return szResult;
}
| macro.c | 630 |
HB_MACRO_PTR | hb_macroCompile( char * szString )
HB_MACRO_PTR hb_macroCompile( char * szString )
{
HB_MACRO_PTR pMacro;
int iStatus;
HB_TRACE(HB_TR_DEBUG, ("hb_macroCompile(%s)", szString));
pMacro = ( HB_MACRO_PTR ) hb_xgrab( sizeof( HB_MACRO ) );
pMacro->mode = HB_MODE_MACRO;
pMacro->supported = s_macroFlags;
pMacro->Flags = HB_MACRO_DEALLOCATE | HB_MACRO_GEN_PUSH |
HB_MACRO_GEN_LIST | HB_MACRO_GEN_PARE;
pMacro->uiNameLen = HB_SYMBOL_NAME_LEN;
pMacro->status = HB_MACRO_CONT;
pMacro->string = szString;
pMacro->length = strlen( szString );
iStatus = hb_macroParse( pMacro );
if( ! ( iStatus == HB_MACRO_OK && ( pMacro->status & HB_MACRO_CONT ) ) )
{
hb_macroDelete( pMacro );
pMacro = NULL;
}
return pMacro;
}
| macro.c | 701 |
VOID | hb_macroPushSymbol( HB_ITEM_PTR pItem )
void hb_macroPushSymbol( HB_ITEM_PTR pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroPushSymbol(%p)", pItem));
if( hb_macroCheckParam( pItem ) )
{
char * szString;
BOOL fNewBuffer;
szString = hb_macroTextSymbol( pItem->item.asString.value,
pItem->item.asString.length,
&fNewBuffer );
if( szString )
{
HB_DYNS_PTR pDynSym = hb_dynsymGetCase( szString );
if( fNewBuffer )
hb_xfree( szString ); /* free space allocated in hb_macroTextSymbol */
hb_stackPop(); /* remove compiled string */
/* NOTE: checking for valid function name (valid pointer) is done
* in hb_vmDo()
*/
hb_vmPushSymbol( pDynSym->pSymbol ); /* push compiled symbol instead of a string */
return;
}
else
hb_macroSyntaxError( NULL );
}
if( !HB_IS_SYMBOL( hb_stackItemFromTop( -1 ) ) && hb_vmRequestQuery() == 0 )
{
hb_stackPop(); /* remove compiled string */
hb_vmPushDynSym( hb_dynsymGetCase( "" ) ); /* push compiled symbol instead of a string */
}
}
| macro.c | 732 |
VOID | hb_macroTextValue( HB_ITEM_PTR pItem )
void hb_macroTextValue( HB_ITEM_PTR pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroTextValue(%p)", pItem));
if( hb_macroCheckParam( pItem ) )
{
char * szString;
ULONG ulLength = pItem->item.asString.length;
szString = hb_macroTextSubst( pItem->item.asString.value, &ulLength );
if( szString != pItem->item.asString.value )
{
/* replace the old value on the eval stack with the new one
*/
hb_itemPutCLPtr( pItem, szString, ulLength );
}
/*
* else
* leave original value on the eval stack - there was no '&' operator
* inside a string
*/
}
}
| macro.c | 776 |
CHAR * | hb_macroGetType( HB_ITEM_PTR pItem )
char * hb_macroGetType( HB_ITEM_PTR pItem )
{
char * szType;
HB_TRACE(HB_TR_DEBUG, ("hb_macroGetType(%p)", pItem));
if( hb_macroCheckParam( pItem ) )
{
HB_MACRO struMacro;
int iStatus;
struMacro.mode = HB_MODE_MACRO;
struMacro.supported = s_macroFlags;
struMacro.Flags = HB_MACRO_GEN_PUSH | HB_MACRO_GEN_TYPE;
struMacro.uiNameLen = HB_SYMBOL_NAME_LEN;
struMacro.status = HB_MACRO_CONT;
struMacro.string = pItem->item.asString.value;
struMacro.length = pItem->item.asString.length;
iStatus = hb_macroParse( &struMacro );
if( iStatus == HB_MACRO_OK )
{
/* passed string was successfully compiled
*/
if( struMacro.exprType == HB_ET_CODEBLOCK )
{
/* Clipper ignores any undeclared symbols or UDFs if the
* compiled expression is a valid codeblock
*/
szType ="B";
}
else if( struMacro.status & HB_MACRO_UNKN_SYM )
{
/* request for a symbol that is not in a symbol table or
* for a variable that is not visible
*/
szType = "U";
}
else if( struMacro.status & HB_MACRO_UDF )
{
szType = "UI"; /* UDF function was used - cannot determine a type */
}
else if( struMacro.status & HB_MACRO_CONT )
{
/* OK - the pcode was generated and it can be evaluated
*/
HB_ERROR_INFO struErr;
HB_ERROR_INFO_PTR pOld;
/* Set our temporary error handler. We do not need any error
* messages here - we need to know only if evaluation was
* successfull. If evaluation was successfull then the data type
* of expression can be determined.
*/
struErr.Func = hb_macroErrorType;
struErr.Cargo = ( void * ) &struMacro;
pOld = hb_errorHandler( &struErr );
hb_macroRun( &struMacro );
hb_errorHandler( pOld );
if( struMacro.status & HB_MACRO_CONT )
{
/* Evaluation was successfull
* Now the value of expression is placed on the eval stack -
* check its type and pop it from the stack
*/
szType = hb_itemTypeStr( hb_stackItemFromTop( -1 ) );
hb_stackPop();
}
else
{
/* something unpleasant happened during macro evaluation */
if( struMacro.pError )
{
ULONG ulGenCode;
ulGenCode = hb_errGetGenCode( struMacro.pError );
if( ulGenCode == EG_NOVAR || ulGenCode == EG_NOALIAS )
{
/* Undeclared variable returns 'U' in Clipper */
szType = "U";
}
else
szType = "UE";
}
else
szType = "UE";
}
}
else
{
szType = "UE";
}
}
else
szType = "UE"; /* syntax error during compilation */
hb_macroDelete( &struMacro );
}
else
szType = "U";
return szType;
}
| macro.c | 806 |
ULONG | hb_macroSetMacro( BOOL bSet, ULONG flag )
ULONG hb_macroSetMacro( BOOL bSet, ULONG flag )
{
ULONG ulCurrentFlags = s_macroFlags;
if( flag > 0 )
{
if( bSet )
s_macroFlags |= flag;
else
s_macroFlags &= ~flag;
}
return ulCurrentFlags;
}
| macro.c | 911 |
HB_FUNC | HB_SETMACRO(void)
HB_FUNC( HB_SETMACRO )
{
int iPrmCnt = hb_pcount();
if( iPrmCnt > 0 )
{
ULONG ulFlags = ( ULONG ) hb_parnl( 1 );
PHB_ITEM pValue;
switch( ulFlags )
{
case HB_SM_HARBOUR:
/* enable/disable extended Harbour compatibility */
hb_retl( s_macroFlags & ulFlags );
pValue = hb_param( 2, HB_IT_LOGICAL );
if( pValue )
hb_macroSetMacro( hb_itemGetL( pValue ), ulFlags );
break;
case HB_SM_XBASE:
/* enable/disable extended xbase compatibility */
hb_retl( s_macroFlags & ulFlags );
pValue = hb_param( 2, HB_IT_LOGICAL );
if( pValue )
hb_macroSetMacro( hb_itemGetL( pValue ), ulFlags );
break;
case HB_SM_ARRSTR :
/* enable/disable processing of strings as an array of bytes */
hb_retl( s_macroFlags & ulFlags );
pValue = hb_param( 2, HB_IT_LOGICAL );
if( pValue )
hb_macroSetMacro( hb_itemGetL( pValue ), ulFlags );
break;
case HB_SM_SHORTCUTS:
/* enable/disable support for shortcut logical operators */
hb_retl( s_macroFlags & ulFlags );
pValue = hb_param( 2, HB_IT_LOGICAL );
if( pValue )
hb_macroSetMacro( hb_itemGetL( pValue ), ulFlags );
break;
default:
;/* do nothing */
}
}
else
hb_ret(); /* return NIL */
}
| macro.c | 930 |
STATIC INT | hb_macroLocalVarGetPos( char * szVarName, HB_COMP_DECL )
static int hb_macroLocalVarGetPos( char * szVarName, HB_COMP_DECL )
{
int iVar = 1;
HB_CBVAR_PTR pVars = HB_PCODE_DATA->pLocals;
while( pVars )
{
if( pVars->szName && ! strcmp( pVars->szName, szVarName ) )
return iVar;
else
{
if( pVars->pNext )
{
pVars = pVars->pNext;
iVar++;
}
else
return 0;
}
}
return 0;
}
| macro.c | 983 |
BOOL | hb_macroIsValidMacroText( char * szText, ULONG ulLen )
BOOL hb_macroIsValidMacroText( char * szText, ULONG ulLen )
{
if( ulLen )
{
while( --ulLen )
{
if( *szText++ == '&' )
{
char ch = *szText;
if( ( ch >= 'A' && ch <= 'Z' ) ||
( ch >= 'a' && ch <= 'z' ) || ch == '_' )
return TRUE;
}
}
}
return FALSE;
}
| macro.c | 1007 |
ULONG | hb_macroGenJump( LONG lOffset, HB_COMP_DECL )
ULONG hb_macroGenJump( LONG lOffset, HB_COMP_DECL )
{
if( lOffset == 0 )
hb_macroGenPCode4( HB_P_JUMPFAR, 0, 0, 0, HB_COMP_PARAM );
else if( HB_LIM_INT8( lOffset ) )
hb_macroGenPCode2( HB_P_JUMPNEAR, HB_LOBYTE( lOffset ), HB_COMP_PARAM );
else if( HB_LIM_INT16( lOffset ) )
hb_macroGenPCode3( HB_P_JUMP, HB_LOBYTE( lOffset ), HB_HIBYTE( lOffset ), HB_COMP_PARAM );
else if( HB_LIM_INT24( lOffset ) )
hb_macroGenPCode4( HB_P_JUMPFAR, HB_LOBYTE( lOffset ), HB_HIBYTE( lOffset ), HB_ULBYTE( lOffset ), HB_COMP_PARAM );
else
hb_macroError( HB_MACRO_TOO_COMPLEX, HB_COMP_PARAM );
return HB_PCODE_DATA->lPCodePos - 3;
}
| macro.c | 1026 |
ULONG | hb_macroGenJumpFalse( LONG lOffset, HB_COMP_DECL )
ULONG hb_macroGenJumpFalse( LONG lOffset, HB_COMP_DECL )
{
if( lOffset == 0 )
hb_macroGenPCode4( HB_P_JUMPFALSEFAR, 0, 0, 0, HB_COMP_PARAM );
else if( HB_LIM_INT8( lOffset ) )
hb_macroGenPCode2( HB_P_JUMPFALSENEAR, HB_LOBYTE( lOffset ), HB_COMP_PARAM );
else if( HB_LIM_INT16( lOffset ) )
hb_macroGenPCode3( HB_P_JUMPFALSE, HB_LOBYTE( lOffset ), HB_HIBYTE( lOffset ), HB_COMP_PARAM );
else if( HB_LIM_INT24( lOffset ) )
hb_macroGenPCode4( HB_P_JUMPFALSEFAR, HB_LOBYTE( lOffset ), HB_HIBYTE( lOffset ), HB_ULBYTE( lOffset ), HB_COMP_PARAM );
else
hb_macroError( HB_MACRO_TOO_COMPLEX, HB_COMP_PARAM );
return HB_PCODE_DATA->lPCodePos - 3;
}
| macro.c | 1042 |
ULONG | hb_macroGenJumpTrue( LONG lOffset, HB_COMP_DECL )
ULONG hb_macroGenJumpTrue( LONG lOffset, HB_COMP_DECL )
{
if( lOffset == 0 )
hb_macroGenPCode4( HB_P_JUMPTRUEFAR, 0, 0, 0, HB_COMP_PARAM );
else if( HB_LIM_INT8( lOffset ) )
hb_macroGenPCode2( HB_P_JUMPTRUENEAR, HB_LOBYTE( lOffset ), HB_COMP_PARAM );
else if( HB_LIM_INT16( lOffset ) )
hb_macroGenPCode3( HB_P_JUMPTRUE, HB_LOBYTE( lOffset ), HB_HIBYTE( lOffset ), HB_COMP_PARAM );
else if( HB_LIM_INT24( lOffset ) )
hb_macroGenPCode4( HB_P_JUMPTRUEFAR, HB_LOBYTE( lOffset ), HB_HIBYTE( lOffset ), HB_ULBYTE( lOffset ), HB_COMP_PARAM );
else
hb_macroError( HB_MACRO_TOO_COMPLEX, HB_COMP_PARAM );
return HB_PCODE_DATA->lPCodePos - 3;
}
| macro.c | 1058 |
VOID | hb_macroGenJumpThere( ULONG ulFrom, ULONG ulTo, HB_COMP_DECL )
void hb_macroGenJumpThere( ULONG ulFrom, ULONG ulTo, HB_COMP_DECL )
{
BYTE * pCode = HB_PCODE_DATA->pCode;
LONG lOffset = ulTo - ulFrom + 1;
if( HB_LIM_INT24( lOffset ) )
HB_PUT_LE_UINT24( &pCode[ ulFrom ], lOffset );
else
hb_macroError( HB_MACRO_TOO_COMPLEX, HB_COMP_PARAM );
}
| macro.c | 1074 |
VOID | hb_macroGenJumpHere( ULONG ulOffset, HB_COMP_DECL )
void hb_macroGenJumpHere( ULONG ulOffset, HB_COMP_DECL )
{
hb_macroGenJumpThere( ulOffset, HB_PCODE_DATA->lPCodePos, HB_COMP_PARAM );
}
| macro.c | 1085 |
STATIC VOID | hb_macroMemvarGenPCode( BYTE bPCode, char * szVarName, HB_COMP_DECL )
static void hb_macroMemvarGenPCode( BYTE bPCode, char * szVarName, HB_COMP_DECL )
{
BYTE byBuf[ sizeof( HB_DYNS_PTR ) + 1 ];
HB_DYNS_PTR pSym;
if( HB_MACRO_DATA->Flags & HB_MACRO_GEN_TYPE )
{
/* we are determining the type of expression (called from TYPE() function)
* then we shouldn't create the requested variable if it doesn't exist
*/
pSym = hb_dynsymFind( szVarName );
if( !pSym )
{
HB_MACRO_DATA->status |= HB_MACRO_UNKN_VAR;
pSym = hb_dynsymGetCase( szVarName );
}
}
else
/* Find the address of passed symbol - create the symbol if doesn't exist
* (Clipper compatibility). */
pSym = hb_dynsymGetCase( szVarName );
byBuf[ 0 ] = bPCode;
HB_PUT_PTR( &byBuf[ 1 ], pSym );
hb_macroGenPCodeN( byBuf, sizeof( byBuf ), HB_COMP_PARAM );
}
| macro.c | 1090 |
VOID | hb_macroGenPushSymbol( char * szSymbolName, BOOL bFunction, HB_COMP_DECL )
void hb_macroGenPushSymbol( char * szSymbolName, BOOL bFunction, HB_COMP_DECL )
{
BYTE byBuf[ sizeof( HB_DYNS_PTR ) + 1 ];
HB_DYNS_PTR pSym;
if( HB_MACRO_DATA->Flags & HB_MACRO_GEN_TYPE )
{
/* we are determining the type of expression (called from TYPE() function)
*/
pSym = hb_dynsymFind( szSymbolName );
if( ! pSym )
{
HB_MACRO_DATA->status |= HB_MACRO_UNKN_SYM;
HB_MACRO_DATA->status &= ~HB_MACRO_CONT; /* don't run this pcode */
/*
* NOTE: the compiled pcode will be not executed then we can ignore
* NULL value for pSym
*/
}
else if( bFunction )
{
if( pSym->pSymbol->value.pFunPtr == NULL )
{
/* static functions are not allowed in macro */
HB_MACRO_DATA->status |= HB_MACRO_UNKN_SYM;
HB_MACRO_DATA->status &= ~HB_MACRO_CONT; /* don't run this pcode */
}
}
}
else
pSym = hb_dynsymGetCase( szSymbolName );
byBuf[ 0 ] = HB_P_MPUSHSYM;
HB_PUT_PTR( &byBuf[ 1 ], pSym );
hb_macroGenPCodeN( byBuf, sizeof( byBuf ), HB_COMP_PARAM );
}
| macro.c | 1120 |
VOID | hb_macroGenPushLong( HB_LONG lNumber, HB_COMP_DECL )
void hb_macroGenPushLong( HB_LONG lNumber, HB_COMP_DECL )
{
if( lNumber == 0 )
{
hb_macroGenPCode1( HB_P_ZERO, HB_COMP_PARAM );
}
else if( lNumber == 1 )
{
hb_macroGenPCode1( HB_P_ONE, HB_COMP_PARAM );
}
else if( HB_LIM_INT8( lNumber ) )
{
hb_macroGenPCode2( HB_P_PUSHBYTE, (BYTE) lNumber, HB_COMP_PARAM );
}
else if( HB_LIM_INT16( lNumber ) )
{
hb_macroGenPCode3( HB_P_PUSHINT, HB_LOBYTE( lNumber ), HB_HIBYTE( lNumber ), HB_COMP_PARAM );
}
else if( HB_LIM_INT32( lNumber ) )
{
BYTE pBuffer[ 5 ];
pBuffer[ 0 ] = HB_P_PUSHLONG;
HB_PUT_LE_UINT32( pBuffer + 1, lNumber );
hb_macroGenPCodeN( pBuffer, sizeof( pBuffer ), HB_COMP_PARAM );
}
else
{
BYTE pBuffer[ 9 ];
pBuffer[ 0 ] = HB_P_PUSHLONGLONG;
HB_PUT_LE_UINT64( pBuffer + 1, lNumber );
hb_macroGenPCodeN( pBuffer, sizeof( pBuffer ), HB_COMP_PARAM );
}
}
| macro.c | 1158 |
VOID | hb_macroGenPushDate( HB_LONG lNumber, HB_COMP_DECL )
void hb_macroGenPushDate( HB_LONG lNumber, HB_COMP_DECL )
{
BYTE pBuffer[ 5 ];
pBuffer[ 0 ] = HB_P_PUSHDATE;
HB_PUT_LE_UINT32( pBuffer + 1, lNumber );
hb_macroGenPCodeN( pBuffer, sizeof( pBuffer ), HB_COMP_PARAM );
}
| macro.c | 1193 |
VOID | hb_macroGenMessage( char * szMsgName, BOOL bIsObject, HB_COMP_DECL )
void hb_macroGenMessage( char * szMsgName, BOOL bIsObject, HB_COMP_DECL )
{
BYTE byBuf[ sizeof( HB_DYNS_PTR ) + 1 ];
/* Find the address of passed symbol - create the symbol if doesn't exist
*/
HB_DYNS_PTR pSym = hb_dynsymGetCase( szMsgName );
byBuf[ 0 ] = HB_P_MMESSAGE;
HB_PUT_PTR( &byBuf[ 1 ], pSym );
hb_macroGenPCodeN( byBuf, sizeof( byBuf ), HB_COMP_PARAM );
HB_SYMBOL_UNUSED( bIsObject ); /* used in full compiler only */
}
| macro.c | 1203 |
VOID | hb_macroGenMessageData( char * szMsg, BOOL bIsObject, HB_COMP_DECL )
void hb_macroGenMessageData( char * szMsg, BOOL bIsObject, HB_COMP_DECL )
{
char * szResult;
int iLen;
HB_TRACE(HB_TR_DEBUG, ("hb_macroGenMessageData(%s)", szMsg));
iLen = ( int ) strlen( szMsg );
if( iLen > HB_SYMBOL_NAME_LEN - 1 )
iLen = HB_SYMBOL_NAME_LEN - 1;
szResult = ( char * ) hb_xgrab( iLen + 2 );
szResult[ 0 ] = '_';
memcpy( szResult + 1, szMsg, iLen );
szResult[ iLen + 1 ] = '\0';
hb_macroGenMessage( szResult, bIsObject, HB_COMP_PARAM );
hb_xfree( szResult );
}
| macro.c | 1219 |
VOID | hb_macroGenPopVar( char * szVarName, HB_COMP_DECL )
void hb_macroGenPopVar( char * szVarName, HB_COMP_DECL )
{
int iVar;
iVar = hb_macroLocalVarGetPos( szVarName, HB_COMP_PARAM );
if( iVar )
{
/* this is a codeblock parameter */
hb_macroGenPCode3( HB_P_POPLOCAL, HB_LOBYTE( iVar ), HB_HIBYTE( iVar ), HB_COMP_PARAM );
}
else
{
/* TODO: memvars created inside TYPE() function should have PUBLIC scope */
hb_macroMemvarGenPCode( HB_P_MPOPMEMVAR, szVarName, HB_COMP_PARAM );
}
}
| macro.c | 1238 |
VOID | hb_macroGenPopMemvar( char * szVarName, HB_COMP_DECL )
void hb_macroGenPopMemvar( char * szVarName, HB_COMP_DECL )
{
hb_macroMemvarGenPCode( HB_P_MPOPMEMVAR, szVarName, HB_COMP_PARAM );
}
| macro.c | 1256 |
VOID | hb_macroGenPopAliasedVar( char * szVarName, BOOL bPushAliasValue, char * szAlias, HB_LONG lWorkarea, HB_COMP_DECL )
void hb_macroGenPopAliasedVar( char * szVarName,
BOOL bPushAliasValue,
char * szAlias,
HB_LONG lWorkarea, HB_COMP_DECL )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroGenPopAliasedVar(%s->%s)",szAlias,szVarName));
if( bPushAliasValue )
{
if( szAlias )
{
int iLen = strlen( szAlias );
if( szAlias[ 0 ] == 'M' && ( iLen == 1 ||
( iLen >= 4 && iLen <= 6 && strncmp( szAlias, "MEMVAR", iLen ) == 0 ) ) )
{ /* M-> or MEMV-> or MEMVA-> or MEMVAR-> variable */
/* TODO: memvars created inside TYPE() function should have PUBLIC scope */
hb_macroMemvarGenPCode( HB_P_MPOPMEMVAR, szVarName, HB_COMP_PARAM );
}
else if( iLen >= 4 && iLen <= 5 && strncmp( szAlias, "FIELD", iLen ) == 0 )
{ /* FIELD-> */
hb_macroMemvarGenPCode( HB_P_MPOPFIELD, szVarName, HB_COMP_PARAM );
}
else
{ /* database alias */
hb_macroGenPushSymbol( szAlias, FALSE, HB_COMP_PARAM );
hb_macroMemvarGenPCode( HB_P_MPOPALIASEDFIELD, szVarName, HB_COMP_PARAM );
}
}
else
{
hb_macroGenPushLong( lWorkarea, HB_COMP_PARAM );
hb_macroMemvarGenPCode( HB_P_MPOPALIASEDFIELD, szVarName, HB_COMP_PARAM );
}
}
else
{
/* Alias is already placed on stack
* NOTE: An alias will be determined at runtime then we cannot decide
* here if passed name is either a field or a memvar
*/
/* TODO: memvars created inside TYPE() function should have PUBLIC scope */
hb_macroMemvarGenPCode( HB_P_MPOPALIASEDVAR, szVarName, HB_COMP_PARAM );
}
}
| macro.c | 1262 |
VOID | hb_macroGenPushVar( char * szVarName, BOOL bMacroVar, HB_COMP_DECL )
void hb_macroGenPushVar( char * szVarName, BOOL bMacroVar, HB_COMP_DECL )
{
int iVar;
HB_SYMBOL_UNUSED( bMacroVar );
iVar = hb_macroLocalVarGetPos( szVarName, HB_COMP_PARAM );
if( iVar )
{
/* this is a codeblock parameter */
hb_macroGenPCode3( HB_P_PUSHLOCAL, HB_LOBYTE( iVar ), HB_HIBYTE( iVar ), HB_COMP_PARAM );
}
else
{
hb_macroMemvarGenPCode( HB_P_MPUSHVARIABLE, szVarName, HB_COMP_PARAM );
}
}
| macro.c | 1311 |
VOID | hb_macroGenPushVarRef( char * szVarName, HB_COMP_DECL )
void hb_macroGenPushVarRef( char * szVarName, HB_COMP_DECL )
{
USHORT iVar;
iVar = hb_macroLocalVarGetPos( szVarName, HB_COMP_PARAM );
if( iVar )
hb_macroGenPCode3( HB_P_PUSHLOCALREF, HB_LOBYTE( iVar ), HB_HIBYTE( iVar ), HB_COMP_PARAM );
else
{
hb_macroMemvarGenPCode( HB_P_MPUSHMEMVARREF, szVarName, HB_COMP_PARAM );
}
}
| macro.c | 1332 |
VOID | hb_macroGenPushMemvarRef( char * szVarName, HB_COMP_DECL )
void hb_macroGenPushMemvarRef( char * szVarName, HB_COMP_DECL )
{
hb_macroMemvarGenPCode( HB_P_MPUSHMEMVARREF, szVarName, HB_COMP_PARAM );
}
| macro.c | 1346 |
VOID | hb_macroGenPushAliasedVar( char * szVarName, BOOL bPushAliasValue, char * szAlias, HB_LONG lWorkarea, HB_COMP_DECL )
void hb_macroGenPushAliasedVar( char * szVarName,
BOOL bPushAliasValue,
char * szAlias,
HB_LONG lWorkarea, HB_COMP_DECL )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroGenPushAliasedVar(%s->%s)",szAlias,szVarName));
if( bPushAliasValue )
{
if( szAlias )
{
/* myalias->var
* FIELD->var
* MEMVAR->var
*/
int iLen = strlen( szAlias );
if( szAlias[ 0 ] == 'M' && ( iLen == 1 ||
( iLen >= 4 && iLen <= 6 && strncmp( szAlias, "MEMVAR", iLen ) == 0 ) ) )
{ /* M-> or MEMV-> or MEMVA-> or MEMVAR-> variable */
hb_macroMemvarGenPCode( HB_P_MPUSHMEMVAR, szVarName, HB_COMP_PARAM );
}
else if( iLen >= 4 && iLen <= 5 && strncmp( szAlias, "FIELD", iLen ) == 0 )
{ /* FIELD-> */
hb_macroMemvarGenPCode( HB_P_MPUSHFIELD, szVarName, HB_COMP_PARAM );
}
else
{ /* database alias */
hb_macroGenPushSymbol( szAlias, FALSE, HB_COMP_PARAM );
hb_macroMemvarGenPCode( HB_P_MPUSHALIASEDFIELD, szVarName, HB_COMP_PARAM );
}
}
else
{
hb_macroGenPushLong( lWorkarea, HB_COMP_PARAM );
hb_macroMemvarGenPCode( HB_P_MPUSHALIASEDFIELD, szVarName, HB_COMP_PARAM );
}
}
else
{
/* Alias is already placed on stack
* NOTE: An alias will be determined at runtime then we cannot decide
* here if passed name is either a field or a memvar
*/
hb_macroMemvarGenPCode( HB_P_MPUSHALIASEDVAR, szVarName, HB_COMP_PARAM );
}
}
| macro.c | 1352 |
VOID | hb_macroGenPushLogical( int iTrueFalse, HB_COMP_DECL )
void hb_macroGenPushLogical( int iTrueFalse, HB_COMP_DECL )
{
if( iTrueFalse )
hb_macroGenPCode1( HB_P_TRUE, HB_COMP_PARAM );
else
hb_macroGenPCode1( HB_P_FALSE, HB_COMP_PARAM );
}
| macro.c | 1403 |
VOID | hb_macroGenPushDouble( double dNumber, BYTE bWidth, BYTE bDec, HB_COMP_DECL )
void hb_macroGenPushDouble( double dNumber, BYTE bWidth, BYTE bDec, HB_COMP_DECL )
{
BYTE pBuffer[ sizeof( double ) + sizeof( BYTE ) + sizeof( BYTE ) + 1 ];
pBuffer[ 0 ] = HB_P_PUSHDOUBLE;
HB_PUT_LE_DOUBLE( &( pBuffer[ 1 ] ), dNumber );
pBuffer[ 1 + sizeof( double ) ] = bWidth;
pBuffer[ 1 + sizeof( double ) + sizeof( BYTE ) ] = bDec;
hb_macroGenPCodeN( pBuffer, 1 + sizeof( double ) + sizeof( BYTE ) + sizeof( BYTE ), HB_COMP_PARAM );
}
| macro.c | 1412 |
VOID | hb_macroGenPushFunSym( char * szFunName, HB_COMP_DECL )
void hb_macroGenPushFunSym( char * szFunName, HB_COMP_DECL )
{
char * szFunction;
szFunction = hb_compReservedName( szFunName );
if( szFunction )
{
/* Abbreviated function name was used - change it for whole name
*/
hb_macroGenPushSymbol( szFunction, TRUE, HB_COMP_PARAM );
}
else
{
HB_MACRO_DATA->status |= HB_MACRO_UDF; /* this is used in hb_macroGetType */
hb_macroGenPushSymbol( szFunName, TRUE, HB_COMP_PARAM );
}
}
| macro.c | 1425 |
VOID | hb_macroGenPushFunCall( char * szFunName, HB_COMP_DECL )
void hb_macroGenPushFunCall( char * szFunName, HB_COMP_DECL )
{
hb_macroGenPushFunSym( szFunName, HB_COMP_PARAM );
hb_macroGenPCode1( HB_P_PUSHNIL, HB_COMP_PARAM );
}
| macro.c | 1443 |
VOID | hb_macroGenPushFunRef( char * szFunName, HB_COMP_DECL )
void hb_macroGenPushFunRef( char * szFunName, HB_COMP_DECL )
{
char * szFunction;
/* if abbreviated function name was used - change it for whole name */
szFunction = hb_compReservedName( szFunName );
hb_macroGenPushSymbol( szFunction ? szFunction : szFunName, TRUE, HB_COMP_PARAM );
}
| macro.c | 1449 |
VOID | hb_macroGenPushString( char * szText, ULONG ulStrLen, HB_COMP_DECL )
void hb_macroGenPushString( char * szText, ULONG ulStrLen, HB_COMP_DECL )
{
if( ulStrLen <= UINT24_MAX )
{
if( ulStrLen <= USHRT_MAX )
hb_macroGenPCode3( HB_P_MPUSHSTR, HB_LOBYTE( ulStrLen ), HB_HIBYTE( ulStrLen ), HB_COMP_PARAM );
else
hb_macroGenPCode4( HB_P_MPUSHSTRLARGE, HB_LOBYTE( ulStrLen ), HB_HIBYTE( ulStrLen ), HB_ULBYTE( ulStrLen ), HB_COMP_PARAM );
hb_macroGenPCodeN( ( BYTE * ) szText, ulStrLen, HB_COMP_PARAM );
}
else
hb_macroError( HB_MACRO_TOO_COMPLEX, HB_COMP_PARAM );
}
| macro.c | 1458 |
VOID | hb_macroGenPCode1( BYTE byte, HB_COMP_DECL )
void hb_macroGenPCode1( BYTE byte, HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA;
if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 1 )
pFunc->pCode = ( BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_SIZE );
pFunc->pCode[ pFunc->lPCodePos++ ] = byte;
}
| macro.c | 1473 |
VOID | hb_macroGenPCode2( BYTE byte1, BYTE byte2, HB_COMP_DECL )
void hb_macroGenPCode2( BYTE byte1, BYTE byte2, HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA;
if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 2 )
pFunc->pCode = ( BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_SIZE );
pFunc->pCode[ pFunc->lPCodePos++ ] = byte1;
pFunc->pCode[ pFunc->lPCodePos++ ] = byte2;
}
| macro.c | 1483 |
VOID | hb_macroGenPCode3( BYTE byte1, BYTE byte2, BYTE byte3, HB_COMP_DECL )
void hb_macroGenPCode3( BYTE byte1, BYTE byte2, BYTE byte3, HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA;
if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 3 )
pFunc->pCode = ( BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_SIZE );
pFunc->pCode[ pFunc->lPCodePos++ ] = byte1;
pFunc->pCode[ pFunc->lPCodePos++ ] = byte2;
pFunc->pCode[ pFunc->lPCodePos++ ] = byte3;
}
| macro.c | 1494 |
VOID | hb_macroGenPCode4( BYTE byte1, BYTE byte2, BYTE byte3, BYTE byte4, HB_COMP_DECL )
void hb_macroGenPCode4( BYTE byte1, BYTE byte2, BYTE byte3, BYTE byte4, HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA;
if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 4 )
pFunc->pCode = ( BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_SIZE );
pFunc->pCode[ pFunc->lPCodePos++ ] = byte1;
pFunc->pCode[ pFunc->lPCodePos++ ] = byte2;
pFunc->pCode[ pFunc->lPCodePos++ ] = byte3;
pFunc->pCode[ pFunc->lPCodePos++ ] = byte4;
}
| macro.c | 1506 |
VOID | hb_macroGenPCodeN( BYTE * pBuffer, ULONG ulSize, HB_COMP_DECL )
void hb_macroGenPCodeN( BYTE * pBuffer, ULONG ulSize, HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA;
if( pFunc->lPCodePos + ulSize > pFunc->lPCodeSize )
{
/* not enough free space in pcode buffer - increase it */
pFunc->lPCodeSize += ( ( ( ulSize / HB_PCODE_SIZE ) + 1 ) * HB_PCODE_SIZE );
pFunc->pCode = ( BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize );
}
memcpy( pFunc->pCode + pFunc->lPCodePos, pBuffer, ulSize );
pFunc->lPCodePos += ulSize;
}
| macro.c | 1519 |
VOID | hb_macroError( int iError, HB_COMP_DECL )
void hb_macroError( int iError, HB_COMP_DECL )
{
HB_MACRO_DATA->status |= iError;
HB_MACRO_DATA->status &= ~HB_MACRO_CONT; /* clear CONT bit */
}
| macro.c | 1536 |
VOID | hb_macroCodeBlockStart( HB_COMP_DECL )
void hb_macroCodeBlockStart( HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pCB;
HB_TRACE(HB_TR_DEBUG, ("hb_macroCodeBlockStart(%p)", HB_COMP_PARAM));
pCB = ( HB_PCODE_INFO_PTR ) hb_xgrab( sizeof( HB_PCODE_INFO ) );
/* replace current pcode buffer with the new one
*/
pCB->pPrev = HB_PCODE_DATA;
HB_PCODE_DATA = pCB;
HB_TRACE(HB_TR_DEBUG, ("hb_macroCodeBlockStart.(%p)", HB_COMP_PARAM));
pCB->pCode = ( BYTE * ) hb_xgrab( HB_PCODE_SIZE );
pCB->lPCodeSize = HB_PCODE_SIZE;
pCB->lPCodePos = 0;
pCB->fVParams = FALSE;
pCB->pLocals = NULL;
}
| macro.c | 1542 |
VOID | hb_macroCodeBlockEnd( HB_COMP_DECL )
void hb_macroCodeBlockEnd( HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pCodeblock; /* pointer to the current codeblock */
ULONG ulSize;
USHORT wParms = 0; /* number of codeblock parameters */
HB_CBVAR_PTR pVar;
HB_TRACE(HB_TR_DEBUG, ("hb_macroCodeBlockEnd(%p)", HB_COMP_PARAM));
/* a currently processed codeblock */
pCodeblock = HB_PCODE_DATA;
/* return to pcode buffer of a codeblock in which the current
* codeblock was defined
*/
HB_PCODE_DATA = pCodeblock->pPrev;
/* generate a proper codeblock frame with a codeblock size and with
* a number of expected parameters
*/
/* Count the number of codeblock parameters */
pVar = pCodeblock->pLocals;
while( pVar )
{
pVar = pVar->pNext;
++wParms;
}
/*NOTE: 6 = HB_P_MPUSHBLOCK + USHORT( size ) + USHORT( wParams ) + _ENDBLOCK
* runtime compiled codeblock cannot reference local variables defined in a
* function
*/
ulSize = ( ULONG ) pCodeblock->lPCodePos + 6;
/*NOTE: HB_P_MPUSHBLOCK differs from HB_P_PUSHBLOCK - the pcode
* is stored in dynamic memory pool instead of static memory
*/
if( ulSize <= USHRT_MAX )
hb_macroGenPCode3( HB_P_MPUSHBLOCK, HB_LOBYTE( ulSize ), HB_HIBYTE( ulSize ), HB_COMP_PARAM );
else
{
++ulSize;
hb_macroGenPCode4( HB_P_MPUSHBLOCKLARGE, HB_LOBYTE( ulSize ), HB_HIBYTE( ulSize ), HB_ULBYTE( ulSize ), HB_COMP_PARAM );
}
hb_macroGenPCode2( HB_LOBYTE( wParms ), HB_HIBYTE( wParms ), HB_COMP_PARAM );
/* copy a codeblock pcode buffer */
hb_macroGenPCodeN( pCodeblock->pCode, pCodeblock->lPCodePos, HB_COMP_PARAM );
hb_macroGenPCode1( HB_P_ENDBLOCK, HB_COMP_PARAM ); /* finish the codeblock */
/* free memory allocated for a codeblock */
hb_xfree( ( void * ) pCodeblock->pCode );
hb_xfree( ( void * ) pCodeblock );
}
| macro.c | 1566 |
maindll.c |
Type | Function | Source | Line |
HB_EXPORT BOOL WINAPI | DllEntryPoint( HINSTANCE hInstance, DWORD fdwReason, PVOID pvReserved )
HB_EXPORT BOOL WINAPI DllEntryPoint( HINSTANCE hInstance, DWORD fdwReason, PVOID pvReserved )
{
HB_TRACE( HB_TR_DEBUG, ("DllEntryPoint(%p, %p, %p)", hInstance, fdwReason,
pvReserved ) );
HB_SYMBOL_UNUSED( hInstance );
HB_SYMBOL_UNUSED( fdwReason );
HB_SYMBOL_UNUSED( pvReserved );
switch( fdwReason )
{
case DLL_PROCESS_ATTACH:
hb_vmInit( FALSE ); /* Don't execute first linked symbol */
break;
case DLL_PROCESS_DETACH:
hb_vmQuit();
break;
}
return TRUE;
}
| maindll.c | 65 |
HB_EXPORT LONG PASCAL | HBDLLENTRY( char * cProcName )
HB_EXPORT LONG PASCAL HBDLLENTRY( char * cProcName )
{
hb_itemDoC( cProcName, 0, 0 );
return 0;
}
| maindll.c | 88 |
HB_EXPORT LONG PASCAL | HBDLLENTRY1( char * cProcName, LONG pItem )
HB_EXPORT LONG PASCAL HBDLLENTRY1( char * cProcName, LONG pItem )
{
hb_itemDoC( cProcName, 1, ( PHB_ITEM ) pItem, 0 );
return 0;
}
| maindll.c | 95 |
HB_EXPORT LONG PASCAL | HBDLLENTRY2( char * cProcName, LONG pItem1, LONG pItem2 )
HB_EXPORT LONG PASCAL HBDLLENTRY2( char * cProcName, LONG pItem1, LONG pItem2 )
{
hb_itemDoC( cProcName, 2, ( PHB_ITEM ) pItem1, ( PHB_ITEM ) pItem2, 0 );
return 0;
}
| maindll.c | 102 |
maindllh.c |
Type | Function | Source | Line |
HB_EXPORT BOOL WINAPI | DllEntryPoint( HINSTANCE hInstance, DWORD fdwReason, PVOID pvReserved )
HB_EXPORT BOOL WINAPI DllEntryPoint( HINSTANCE hInstance, DWORD fdwReason, PVOID pvReserved )
{
HB_TRACE( HB_TR_DEBUG, ("DllEntryPoint(%p, %p, %d)", hInstance, fdwReason,
pvReserved ) );
HB_SYMBOL_UNUSED( hInstance );
HB_SYMBOL_UNUSED( fdwReason );
HB_SYMBOL_UNUSED( pvReserved );
switch( fdwReason )
{
case DLL_PROCESS_ATTACH:
break;
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
| maindllh.c | 65 |
maindllp.c |
Type | Function | Source | Line |
HB_EXTERN_BEGIN STATIC FARPROC | hb_getProcAddress( LPCSTR szProcName )
static FARPROC hb_getProcAddress( LPCSTR szProcName )
{
static HMODULE s_hModule = NULL;
FARPROC pProcAddr = NULL;
if( s_hModule == NULL )
{
s_hModule = GetModuleHandle( HB_DLL_NAME );
#ifdef HB_DLL_NAME2
if( s_hModule == NULL )
s_hModule = GetModuleHandle( HB_DLL_NAME2 );
#endif
if( s_hModule == NULL )
s_hModule = GetModuleHandle( NULL );
}
if( s_hModule )
{
pProcAddr = GetProcAddress( s_hModule, szProcName );
if( pProcAddr == NULL && szProcName[ 0 ] == '_' )
pProcAddr = GetProcAddress( s_hModule, szProcName + 1 );
}
if( pProcAddr == NULL )
{
LPTSTR lpFuncName = HB_TCHAR_CONVTO( szProcName );
MessageBox( NULL, TEXT( "Cannot find function address" ),
lpFuncName, MB_ICONSTOP );
HB_TCHAR_FREE( lpFuncName );
}
return pProcAddr;
}
| maindllp.c | 73 |
HB_EXPORT BOOL WINAPI | DllEntryPoint( HINSTANCE hInstance, DWORD fdwReason, PVOID pvReserved )
HB_EXPORT BOOL WINAPI DllEntryPoint( HINSTANCE hInstance, DWORD fdwReason, PVOID pvReserved )
{
HB_TRACE( HB_TR_DEBUG, ("DllEntryPoint(%p, %p, %d)", hInstance, fdwReason,
pvReserved ) );
HB_SYMBOL_UNUSED( hInstance );
HB_SYMBOL_UNUSED( fdwReason );
HB_SYMBOL_UNUSED( pvReserved );
switch( fdwReason )
{
case DLL_PROCESS_ATTACH:
break;
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
| maindllp.c | 106 |
PHB_SYMB | hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols )
PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols )
{
/* notice hb_vmProcessDllSymbols() must be used, and not
* hb_vmProcessSymbols(), as some special symbols pointers
* adjustments are required
*/
static FARPROC s_pProcessSymbols = NULL;
if( !s_pProcessSymbols )
s_pProcessSymbols = hb_getProcAddress( "_hb_vmProcessDllSymbols" );
if( s_pProcessSymbols )
return ( ( VM_PROCESS_DLL_SYMBOLS ) s_pProcessSymbols ) ( pSymbols,
uiSymbols );
/* else
* may we issue an error ? */
return pSymbols;
}
| maindllp.c | 127 |
PHB_SYMB | hb_vmProcessSymbolsEx( PHB_SYMB pSymbols, USHORT uiSymbols, char * szModuleName, ULONG ulID, USHORT uiPcodeVer )
PHB_SYMB hb_vmProcessSymbolsEx( PHB_SYMB pSymbols, USHORT uiSymbols, char * szModuleName, ULONG ulID, USHORT uiPcodeVer ) /* module symbols initialization with extended information */
{
static FARPROC s_pProcessSymbols = NULL;
if( !s_pProcessSymbols )
s_pProcessSymbols = hb_getProcAddress( "_hb_vmProcessSymbolsEx" );
if( s_pProcessSymbols )
return ( ( VM_PROCESS_SYMBOLS_EX ) s_pProcessSymbols )
( pSymbols, uiSymbols, szModuleName, ulID, uiPcodeVer );
/* else
* may we issue an error ? */
return pSymbols;
}
| maindllp.c | 148 |
VOID | hb_vmExecute( const BYTE * pCode, PHB_SYMB pSymbols )
void hb_vmExecute( const BYTE * pCode, PHB_SYMB pSymbols )
{
static FARPROC s_pExecute = NULL;
if( !s_pExecute )
s_pExecute = hb_getProcAddress( "_hb_vmExecute" );
if( s_pExecute )
( ( VM_DLL_EXECUTE ) s_pExecute ) ( pCode, pSymbols );
/* else
* may we issue an error ? */
}
| maindllp.c | 165 |
CHAR * | hb_parc( int iParam, ... )
char * hb_parc( int iParam, ... )
{
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
FARPROC pParC = GetProcAddress( GetModuleHandle( NULL ), "_hb_parc" );
if( pExtIsArray && pParC )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return ( ( EXT_PARC2 ) pParC )( iParam, ulArrayIndex );
}
else
return ( ( EXT_PARC1 ) pParC )( iParam );
}
return NULL;
}
| maindllp.c | 182 |
PHB_ITEM | hb_param( int iParam, long lMask )
PHB_ITEM hb_param( int iParam, long lMask ) /* retrieve a generic parameter */
{
PHB_ITEM pReturn = NULL;
FARPROC pParam = GetProcAddress( GetModuleHandle( NULL ), "_hb_param" );
if( pParam )
pReturn = ( ( HB_PARAM ) pParam )( iParam, lMask );
return pReturn;
}
| maindllp.c | 207 |
PHB_ITEM | hb_paramError( int iParam )
PHB_ITEM hb_paramError( int iParam ) /* Returns either the generic parameter or a NIL item if param not provided */
{
PHB_ITEM pReturn = NULL;
FARPROC pParamError = GetProcAddress( GetModuleHandle( NULL ), "_hb_paramError" );
if( pParamError )
pReturn = ((HB_PARAMERROR)pParamError)(iParam);
return pReturn;
}
| maindllp.c | 216 |
INT | hb_pcount( void )
int hb_pcount( void ) /* returns the number of suplied parameters */
{
int iReturn = 0;
FARPROC pCounts = GetProcAddress( GetModuleHandle( NULL ), "_hb_pcount" );
if( pCounts )
iReturn = ((HB_PCOUNTS)pCounts)();
return iReturn;
}
| maindllp.c | 224 |
VOID | hb_retc( const char * szText )
void hb_retc( const char * szText ) /* returns a string */
{
FARPROC pRetc=GetProcAddress(GetModuleHandle( NULL ), "_hb_retc" );
if( pRetc )
((HB_RETC)pRetc)(szText);
}
| maindllp.c | 233 |
VOID | hb_retclen( const char * szText, ULONG ulLen )
void hb_retclen( const char * szText, ULONG ulLen ) /* returns a string with a specific length */
{
FARPROC pRetclen = GetProcAddress(GetModuleHandle( NULL ), "_hb_retclen" );
if( pRetclen )
((HB_RETCLEN)pRetclen)(szText,ulLen);
}
| maindllp.c | 240 |
VOID | hb_retds( const char * szDate )
void hb_retds( const char * szDate ) /* returns a date, must use yyyymmdd format */
{
FARPROC pRetds = GetProcAddress(GetModuleHandle( NULL ), "_hb_retds" );
if( pRetds )
((HB_RETDS)pRetds)(szDate);
}
| maindllp.c | 247 |
VOID | hb_retd( int iYear, int iMonth, int iDay )
void hb_retd( int iYear, int iMonth, int iDay ) /* returns a date */
{
FARPROC pRetd = GetProcAddress(GetModuleHandle( NULL ), "_hb_retd" );
if( pRetd )
((HB_RETD)pRetd)( iYear, iMonth, iDay );
}
| maindllp.c | 254 |
VOID | hb_retdl( long lJulian )
void hb_retdl( long lJulian ) /* returns a long value as a julian date */
{
FARPROC pRet = GetProcAddress(GetModuleHandle( NULL ), "_hb_retdl" );
if( pRet )
((HB_RETDL)pRet)(lJulian);
}
| maindllp.c | 261 |
VOID | hb_retl( int iTrueFalse )
void hb_retl( int iTrueFalse ) /* returns a logical integer */
{
FARPROC pRet = GetProcAddress(GetModuleHandle( NULL ), "_hb_retl" );
if( pRet )
((HB_RETDL)pRet)(iTrueFalse);
}
| maindllp.c | 269 |
VOID | hb_retnd( double dNumber )
void hb_retnd( double dNumber ) /* returns a double */
{
FARPROC pRet = GetProcAddress(GetModuleHandle( NULL ), "_hb_retnd" );
if( pRet )
((HB_RETND)pRet)(dNumber);
}
| maindllp.c | 276 |
VOID | hb_retni( int iNumber )
void hb_retni( int iNumber ) /* returns a integer number */
{
FARPROC pRet = GetProcAddress(GetModuleHandle( NULL ), "_hb_retni" );
if( pRet )
((HB_RETNI)pRet)(iNumber);
}
| maindllp.c | 283 |
VOID | hb_retnl( long lNumber )
void hb_retnl( long lNumber ) /* returns a long number */
{
FARPROC pRet = GetProcAddress(GetModuleHandle( NULL ), "_hb_retnl" );
if( pRet )
((HB_RETNL)pRet)(lNumber);
}
| maindllp.c | 291 |
VOID | hb_retnlen( double dNumber, int iWidth, int iDec )
void hb_retnlen( double dNumber, int iWidth, int iDec ) /* returns a double, with specific width and decimals */
{
FARPROC pRet = GetProcAddress(GetModuleHandle( NULL ), "_hb_retnlen" );
if( pRet )
((HB_RETNLEN)pRet)(dNumber,iWidth,iDec);
}
| maindllp.c | 298 |
VOID | hb_retndlen( double dNumber, int iWidth, int iDec )
void hb_retndlen( double dNumber, int iWidth, int iDec ) /* returns a double, with specific width and decimals */
{
FARPROC pRet = GetProcAddress(GetModuleHandle( NULL ), "_hb_retndlen" );
if( pRet )
((HB_RETNDLEN)pRet)(dNumber,iWidth,iDec);
}
| maindllp.c | 305 |
VOID | hb_retnilen( int iNumber, int iWidth )
void hb_retnilen( int iNumber, int iWidth ) /* returns a integer number, with specific width */
{
FARPROC pRet = GetProcAddress(GetModuleHandle( NULL ), "_hb_retnilen" );
if( pRet )
((HB_RETNILEN)pRet)(iNumber,iWidth);
}
| maindllp.c | 312 |
VOID | hb_retnllen( long lNumber, int iWidth )
void hb_retnllen( long lNumber, int iWidth ) /* returns a long number, with specific width */
{
FARPROC pRet = GetProcAddress(GetModuleHandle( NULL ), "_hb_retnilen" );
if( pRet )
((HB_RETNLLEN)pRet)(lNumber,iWidth);
}
| maindllp.c | 319 |
VOID | hb_reta( ULONG ulLen )
void hb_reta( ULONG ulLen ) /* returns an array with a specific length */
{
FARPROC pRet = GetProcAddress(GetModuleHandle( NULL ), "_hb_reta" );
if( pRet )
((HB_RETA)pRet)(ulLen);
}
| maindllp.c | 326 |
ULONG | hb_parinfa( int iParamNum, ULONG uiArrayIndex )
ULONG hb_parinfa( int iParamNum, ULONG uiArrayIndex ) /* retrieve length or element type of an array parameter */
{
ULONG ulReturn = 0;
FARPROC pParinfa = GetProcAddress( GetModuleHandle( NULL ), "_hb_parinfa" );
if( pParinfa )
ulReturn = ((HB_PARINFA)pParinfa)(iParamNum,uiArrayIndex);
return ulReturn;
}
| maindllp.c | 333 |
ULONG | hb_parinfo( int iParam )
ULONG hb_parinfo( int iParam ) /* Determine the param count or data type */
{
ULONG ulReturn = 0;
FARPROC pParinfo = GetProcAddress( GetModuleHandle( NULL ), "_hb_parinfo" );
if( pParinfo )
ulReturn = ((HB_PARINFO)pParinfo)(iParam);
return ulReturn;
}
| maindllp.c | 342 |
ULONG | hb_parclen( int iParam, ... )
ULONG hb_parclen( int iParam, ... ) /* retrieve a string parameter length */
{
FARPROC pParC = GetProcAddress( GetModuleHandle( NULL ), "_hb_parclen" );
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
if( pExtIsArray && pParC )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return ( ( HB_PARCLEN2 ) pParC )( iParam, ulArrayIndex );
}
else
return ( ( HB_PARCLEN ) pParC )( iParam );
}
return 0;
}
| maindllp.c | 351 |
ULONG | hb_parcsiz( int iParam, ... )
ULONG hb_parcsiz( int iParam, ... )/* retrieve a by-reference string parameter length, including terminator */
{
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
FARPROC pParcSiz = GetProcAddress( GetModuleHandle( NULL ), "_hb_parcsiz" );
if( pExtIsArray && pParcSiz )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return ( ( HB_PARCSIZ2 ) pParcSiz )( iParam, ulArrayIndex );
}
else
return ( ( HB_PARCSIZ ) pParcSiz )( iParam );
}
return 0;
}
| maindllp.c | 375 |
CHAR * | hb_pards( int iParam, ... )
char * hb_pards( int iParam, ... ) /* retrieve a date as a string yyyymmdd */
{
FARPROC pParDs = GetProcAddress( GetModuleHandle( NULL ), "_hb_pards" );
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
if( pExtIsArray && pParDs )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return ( ( HB_PARDS2 ) pParDs )( iParam, ulArrayIndex );
}
else
return ( ( HB_PARDS ) pParDs )( iParam );
}
return "";
}
| maindllp.c | 400 |
CHAR * | hb_pardsbuff( char * szDate, int iParam, ... )
char * hb_pardsbuff( char * szDate, int iParam, ... ) /* retrieve a date as a string yyyymmdd */
{
FARPROC pParDsBuff = GetProcAddress( GetModuleHandle( NULL ), "_hb_pardsbuff" );
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
if( pExtIsArray && pParDsBuff )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return ( ( HB_PARDSBUFF2 ) pParDsBuff )( szDate, iParam, ulArrayIndex );
}
else
return ( ( HB_PARDSBUFF ) pParDsBuff )( szDate, iParam );
}
return "";
}
| maindllp.c | 425 |
INT | hb_parl( int iParam, ... )
int hb_parl( int iParam, ... ) /* retrieve a logical parameter as an int */
{
/* int iReturn; */
FARPROC pParL = GetProcAddress( GetModuleHandle( NULL ), "_hb_parl" );
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
if( pExtIsArray && pParL )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return ( ( HB_PARL2 ) pParL )( iParam, ulArrayIndex );
}
else
return ( ( HB_PARL ) pParL )( iParam );
}
return 0;
}
| maindllp.c | 450 |
DOUBLE | hb_parnd( int iParam, ... )
double hb_parnd( int iParam, ... ) /* retrieve a numeric parameter as a double */
{
FARPROC pParNd = GetProcAddress( GetModuleHandle( NULL ), "_hb_parnd" );
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
if( pExtIsArray && pParNd )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return ( ( HB_PARND2 ) pParNd )( iParam, ulArrayIndex );
}
else
return ( ( HB_PARND ) pParNd )( iParam );
}
return 0;
}
| maindllp.c | 476 |
INT | hb_parni( int iParam, ... )
int hb_parni( int iParam, ... ) /* retrieve a numeric parameter as a integer */
{
/* int iReturn; */
FARPROC pParNi = GetProcAddress( GetModuleHandle( NULL ), "_hb_parni" );
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
if( pExtIsArray && pParNi )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return ( ( HB_PARNI2 ) pParNi )( iParam, ulArrayIndex );
}
else
return ( ( HB_PARNI ) pParNi )( iParam );
}
return 0;
}
| maindllp.c | 502 |
LONG | hb_parnl( int iParam, ... )
long hb_parnl( int iParam, ... ) /* retrieve a numeric parameter as a long */
{
FARPROC pParNl = GetProcAddress( GetModuleHandle( NULL ), "_hb_parnl" );
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
if( pExtIsArray && pParNl )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
return ( ( HB_PARNL2 ) pParNl )( iParam, ulArrayIndex );
}
else
return ( ( HB_PARNL ) pParNl )( iParam );
}
return 0;
}
| maindllp.c | 528 |
INT | hb_storc( char * szText, int iParam, ... )
int hb_storc( char * szText, int iParam, ... )
{
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
FARPROC pStorC = GetProcAddress( GetModuleHandle( NULL ), "_hb_storc" );
if( pExtIsArray && pStorC )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
( ( HB_STORC2) pStorC )( szText, iParam, ulArrayIndex );
return 1;
}
else
{
( ( HB_STORC ) pStorC )( szText, iParam );
return 1;
}
}
return 0;
}
| maindllp.c | 554 |
INT | hb_storclen( char * szText, ULONG ulLen, int iParam, ... )
int hb_storclen( char * szText, ULONG ulLen, int iParam, ... )
{
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
FARPROC pStorC = GetProcAddress( GetModuleHandle( NULL ), "_hb_storclen" );
if( pExtIsArray && pStorC )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
( ( HB_STORCLEN2) pStorC )( szText, ulLen, iParam, ulArrayIndex );
return 1;
}
else
{
( ( HB_STORCLEN ) pStorC )( szText, ulLen, iParam );
return 1;
}
}
return 0;
}
| maindllp.c | 583 |
INT | hb_stords( char * szDate, int iParam, ... )
int hb_stords( char * szDate, int iParam, ... )
{
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
FARPROC pStorDs = GetProcAddress( GetModuleHandle( NULL ), "_hb_stords" );
if( pExtIsArray && pStorDs )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
( ( HB_STORDS2) pStorDs )( szDate, iParam, ulArrayIndex );
return 1;
}
else
{
( ( HB_STORDS ) pStorDs )( szDate, iParam );
return 1;
}
}
return 0;
}
| maindllp.c | 613 |
INT | hb_storl( int iLogical, int iParam, ... )
int hb_storl( int iLogical, int iParam, ... )
{
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
FARPROC pStorL = GetProcAddress( GetModuleHandle( NULL ), "_hb_storl" );
if( pExtIsArray && pStorL )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
( ( HB_STORL2) pStorL )( iLogical, iParam, ulArrayIndex );
return 1;
}
else
{
( ( HB_STORL ) pStorL )( iLogical, iParam );
return 1;
}
}
return 0;
}
| maindllp.c | 644 |
INT | hb_storni( int iValue, int iParam, ... )
int hb_storni( int iValue, int iParam, ... )
{
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
FARPROC pStorNi = GetProcAddress( GetModuleHandle( NULL ), "_hb_storni" );
if( pExtIsArray && pStorNi )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
( ( HB_STORNI2) pStorNi )( iValue, iParam, ulArrayIndex );
return 1;
}
else
{
( ( HB_STORNI) pStorNi )( iValue, iParam );
return 1;
}
}
return 0;
}
| maindllp.c | 674 |
INT | hb_stornl( long lValue, int iParam, ... )
int hb_stornl( long lValue, int iParam, ... )
{
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
FARPROC pStorNl = GetProcAddress( GetModuleHandle( NULL ), "_hb_stornl" );
if( pExtIsArray && pStorNl )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
( ( HB_STORNL2) pStorNl )( lValue, iParam, ulArrayIndex );
return 1;
}
else
{
( ( HB_STORNL) pStorNl )( lValue, iParam );
return 1;
}
}
return 0;
}
| maindllp.c | 704 |
INT | hb_stornd( double dNumber, int iParam, ... )
int hb_stornd( double dNumber, int iParam, ... )
{
FARPROC pExtIsArray = GetProcAddress( GetModuleHandle( NULL ), "_hb_extIsArray" );
FARPROC pStorNd = GetProcAddress( GetModuleHandle( NULL ), "_hb_stornd" );
if( pExtIsArray && pStorNd )
{
if( ( ( EXT_IS_ARRAY ) pExtIsArray ) ( iParam ) )
{
va_list va;
ULONG ulArrayIndex;
va_start( va, iParam );
ulArrayIndex = va_arg( va, ULONG );
va_end( va );
( ( HB_STORND2) pStorNd )( dNumber, iParam, ulArrayIndex );
return 1;
}
else
{
( ( HB_STORND) pStorNd )( dNumber, iParam );
return 1;
}
}
return 0;
}
| maindllp.c | 734 |
BOOL | hb_arrayNew( PHB_ITEM pItem, ULONG ulLen )
BOOL hb_arrayNew( PHB_ITEM pItem, ULONG ulLen ) /* creates a new array */
{
HB_ARRAYNEW pArrayNew = (HB_ARRAYNEW) GetProcAddress( GetModuleHandle( NULL ), "_hb_arrayNew" );
if( pArrayNew )
return pArrayNew( pItem, ulLen );
else
return FALSE;
}
| maindllp.c | 764 |
ULONG | hb_arrayLen( PHB_ITEM pArray )
ULONG hb_arrayLen( PHB_ITEM pArray ) /* retrives the array len */
{
HB_ARRAYLEN pArrayLen = (HB_ARRAYLEN)GetProcAddress( GetModuleHandle( NULL ), "_hb_arrayLen" );
if( pArrayLen )
return pArrayLen( pArray );
else
return 0;
}
| maindllp.c | 773 |
BOOL | hb_arrayIsObject( PHB_ITEM pArray )
BOOL hb_arrayIsObject( PHB_ITEM pArray ) /* retrives if the array is an object */
{
HB_ARRAYISOBJECT pArrayIsObject = (HB_ARRAYISOBJECT)GetProcAddress( GetModuleHandle( NULL ), "_hb_arrayIsObject" );
if( pArrayIsObject )
return pArrayIsObject( pArray );
else
return FALSE;
}
| maindllp.c | 782 |
BOOL | hb_arrayAdd( PHB_ITEM pArray, PHB_ITEM pItemValue )
BOOL hb_arrayAdd( PHB_ITEM pArray, PHB_ITEM pItemValue ) /* add a new item to the end of an array item */
{
HB_ARRAYADD pArrayAdd = (HB_ARRAYADD)GetProcAddress( GetModuleHandle( NULL ), "_hb_arrayAdd" );
if( pArrayAdd )
return pArrayAdd( pArray, pItemValue );
else
return FALSE;
}
| maindllp.c | 791 |
BOOL | hb_arrayIns( PHB_ITEM pArray, ULONG ulIndex )
BOOL hb_arrayIns( PHB_ITEM pArray, ULONG ulIndex ) /* insert a nil item into an array, without changing the length */
{
HB_ARRAYINS pArrayIns = (HB_ARRAYINS)GetProcAddress( GetModuleHandle( NULL ), "_hb_arrayIns" );
if( pArrayIns )
return pArrayIns( pArray, ulIndex );
else
return FALSE;
}
| maindllp.c | 800 |
BOOL | hb_arrayDel( PHB_ITEM pArray, ULONG ulIndex )
BOOL hb_arrayDel( PHB_ITEM pArray, ULONG ulIndex ) /* delete an array item, without changing length */
{
HB_ARRAYDEL pArrayDel = (HB_ARRAYDEL)GetProcAddress( GetModuleHandle( NULL ), "_hb_arrayDel" );
if( pArrayDel )
return pArrayDel( pArray, ulIndex );
else
return FALSE;
}
| maindllp.c | 809 |
BOOL | hb_arraySize( PHB_ITEM pArray, ULONG ulLen )
BOOL hb_arraySize( PHB_ITEM pArray, ULONG ulLen ) /* sets the array total length */
{
HB_ARRAYSIZE pArraySize = (HB_ARRAYSIZE)GetProcAddress( GetModuleHandle( NULL ), "_hb_arraySize" );
if( pArraySize )
return pArraySize( pArray, ulLen );
else
return FALSE;
}
| maindllp.c | 818 |
BOOL | hb_arrayLast( PHB_ITEM pArray, PHB_ITEM pResult )
BOOL hb_arrayLast( PHB_ITEM pArray, PHB_ITEM pResult ) /* retrieve last item in an array */
{
HB_ARRAYLAST pArrayLast= (HB_ARRAYLAST)GetProcAddress( GetModuleHandle( NULL ), "_hb_arrayLast" );
if( pArrayLast )
return pArrayLast( pArray, pResult );
else
return FALSE;
}
| maindllp.c | 827 |
BOOL | hb_arraySet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
BOOL hb_arraySet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem ) /* sets an array element */
{
HB_ARRAYSET pArraySet = (HB_ARRAYSET)GetProcAddress( GetModuleHandle( NULL ), "_hb_arraySet" );
if( pArraySet )
return pArraySet( pArray, ulIndex, pItem);
else
return FALSE;
}
| maindllp.c | 836 |
BOOL | hb_arrayGet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem )
BOOL hb_arrayGet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem ) /* retrieves an item */
{
HB_ARRAYGET pArrayGet = (HB_ARRAYGET)GetProcAddress( GetModuleHandle( NULL ), "_hb_arrayGet" );
if( pArrayGet )
return pArrayGet( pArray, ulIndex, pItem);
else
return FALSE;
}
| maindllp.c | 845 |
VOID | hb_xinit( void )
void hb_xinit( void ) /* Initialize fixed memory subsystem */
{
HB_XINIT pXinit = (HB_XINIT)GetProcAddress( GetModuleHandle( NULL ), "_hb_xinit" );
if( pXinit )
pXinit();
}
| maindllp.c | 854 |
VOID | hb_xexit( void )
void hb_xexit( void ) /* Deinitialize fixed memory subsystem */
{
HB_XEXIT pXexit = (HB_XEXIT)GetProcAddress( GetModuleHandle( NULL ), "_hb_xexit" );
if( pXexit )
pXexit();
}
| maindllp.c | 861 |
VOID * | hb_xalloc( ULONG ulSize )
void * hb_xalloc( ULONG ulSize ) /* allocates memory, returns NULL on failure */
{
void * pRet = NULL;
HB_XALLOC pXalloc = (HB_XALLOC)GetProcAddress( GetModuleHandle( NULL ), "_hb_xalloc" );
if( pXalloc )
pRet=pXalloc( ulSize );
return pRet;
}
| maindllp.c | 868 |
VOID * | hb_xgrab( ULONG ulSize )
void * hb_xgrab( ULONG ulSize ) /* allocates memory, exits on failure */
{
void * pRet = NULL;
HB_XGRAB pXgrab = (HB_XGRAB)GetProcAddress( GetModuleHandle( NULL ), "_hb_xgrab" );
if( pXgrab )
pRet = pXgrab( ulSize );
return pRet;
}
| maindllp.c | 877 |
VOID | hb_xfree( void * pMem )
void hb_xfree( void * pMem ) /* frees memory */
{
HB_XFREE pXfree = (HB_XFREE)GetProcAddress( GetModuleHandle( NULL ), "_hb_xfree" );
if( pXfree )
pXfree( pMem );
}
| maindllp.c | 886 |
VOID * | hb_xrealloc( void * pMem, ULONG ulSize )
void * hb_xrealloc( void * pMem, ULONG ulSize ) /* reallocates memory */
{
void * pRet = NULL;
HB_XREALLOC pXrealloc = (HB_XREALLOC)GetProcAddress( GetModuleHandle( NULL ), "_hb_xrealloc" );
if( pXrealloc )
pRet = (void*) pXrealloc( pMem, ulSize );
return pRet;
}
| maindllp.c | 893 |
ULONG | hb_xsize( void * pMem )
ULONG hb_xsize( void * pMem ) /* returns the size of an allocated memory block */
{
HB_XSIZE pXsize = (HB_XSIZE)GetProcAddress( GetModuleHandle( NULL ), "_hb_xsize" );
ULONG ulReturn = 0;
if( pXsize )
ulReturn = pXsize( (void *)pMem );
return ulReturn;
}
HB_EXTERN_END
| maindllp.c | 902 |
mainpm.c |
Type | Function | Source | Line |
INT | main( int argc, char * argv[] )
int main( int argc, char * argv[] )
{
int iErrorCode;
HAB hab; /* Anchor Block handle */
HMQ hmq; /* Message Queue handle */
hab = WinInitialize( 0 );
hmq = WinCreateMsgQueue( hab, 0 );
hb_cmdargInit( argc, argv );
hb_vmInit( TRUE );
iErrorCode = hb_vmQuit();
WinDestroyMsgQueue( hmq );
WinTerminate( hab );
return iErrorCode;
}
| mainpm.c | 62 |
mainstd.c |
Type | Function | Source | Line |
INT | main( int argc, char * argv[] )
int main( int argc, char * argv[] )
{
HB_TRACE(HB_TR_DEBUG, ("main(%d, %p)", argc, argv));
hb_cmdargInit( argc, argv );
hb_vmInit( TRUE );
return hb_vmQuit();
}
| mainstd.c | 61 |
CHAR ** | __crt0_glob_function( char * _arg )
char ** __crt0_glob_function( char * _arg )
{
/* This function disables command line wildcard expansion. */
HB_SYMBOL_UNUSED( _arg );
return 0;
}
| mainstd.c | 71 |
HB_EXPORT VOID | hb_forceLinkMainStd( void )
HB_EXPORT void hb_forceLinkMainStd( void ) {}
#endif
HB_EXTERN_END
| mainstd.c | 81 |
mainwin.c |
Type | Function | Source | Line |
INT WINAPI | WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, HB_LPSTR lpCmdLine, int iCmdShow )
int WINAPI WinMain( HINSTANCE hInstance, /* handle to current instance */
HINSTANCE hPrevInstance, /* handle to previous instance */
HB_LPSTR lpCmdLine, /* pointer to command line */
int iCmdShow ) /* show state of window */
{
TCHAR szAppName[ MAX_PATH ];
LPSTR pArgs, pArg, pDst, pSrc, pFree;
BOOL fQuoted;
int iErrorCode;
HB_TRACE(HB_TR_DEBUG, ("WinMain(%p, %p, %s, %d)", hInstance, hPrevInstance, lpCmdLine, iCmdShow));
GetModuleFileName( hInstance, szAppName, MAX_PATH );
HB_TCHAR_GETFROM( s_szAppName, szAppName, MAX_PATH );
s_argv[ s_argc++ ] = s_szAppName;
pArg = NULL;
#if defined( HB_WINCE )
pSrc = pFree = hb_wctomb( lpCmdLine );
#else
pSrc = pFree = lpCmdLine;
#endif
pDst = pArgs = ( LPSTR ) LocalAlloc( LMEM_FIXED, strlen( pFree ) + 1 );
fQuoted = FALSE;
while( *pSrc != 0 && s_argc < MAX_ARGS )
{
if( *pSrc == '"' )
{
if( pArg == NULL )
pArg = pDst;
fQuoted = !fQuoted;
}
else if( fQuoted || !HB_ISSPACE( *pSrc ) )
{
if( pArg == NULL )
pArg = pDst;
*pDst++ = *pSrc;
}
else
{
if( pArg )
{
*pDst++ = '\0';
s_argv[ s_argc++ ] = pArg;
pArg = NULL;
}
}
++pSrc;
}
if( pArg )
{
*pDst = '\0';
s_argv[ s_argc++ ] = pArg;
}
#if defined( HB_WINCE )
HB_TCHAR_FREE( pFree );
#endif
hb_winmainArgInit( hInstance, hPrevInstance, iCmdShow );
hb_cmdargInit( s_argc, s_argv );
hb_vmInit( TRUE );
iErrorCode = hb_vmQuit();
LocalFree( pArgs );
return iErrorCode;
}
| mainwin.c | 71 |
HB_EXTERN_BEGIN HB_EXPORT VOID | hb_forceLinkMainWin( void )
HB_EXTERN_BEGIN
HB_EXPORT void hb_forceLinkMainWin( void ) {}
HB_EXTERN_END
| mainwin.c | 143 |
memvars.c |
Type | Function | Source | Line |
VOID | hb_memvarsInit( void )
void hb_memvarsInit( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarsInit()"));
s_globalTable = ( HB_VALUE_PTR ) hb_xgrab( sizeof( HB_VALUE ) * TABLE_INITHB_VALUE );
s_globalTableSize = TABLE_INITHB_VALUE;
s_globalFirstFree = 0;
s_globalLastFree = 1;
s_privateStack = ( PHB_DYNS * ) hb_xgrab( sizeof( PHB_DYNS ) * TABLE_INITHB_VALUE );
s_privateStackSize = TABLE_INITHB_VALUE;
s_privateStackCnt = s_privateStackBase = 0;
}
| memvars.c | 102 |
VOID | hb_memvarsFree( void )
void hb_memvarsFree( void )
{
if( s_globalTable )
hb_xfree( s_globalTable );
if( s_privateStack )
hb_xfree( s_privateStack );
}
| memvars.c | 116 |
HB_VALUE_PTR | hb_memvarValueBaseAddress( void )
HB_VALUE_PTR *hb_memvarValueBaseAddress( void )
{
return &s_globalTable;
}
| memvars.c | 125 |
STATIC HB_HANDLE | hb_memvarValueNew( HB_ITEM_PTR pSource, HB_HANDLE hPrevMemvar )
static HB_HANDLE hb_memvarValueNew( HB_ITEM_PTR pSource, HB_HANDLE hPrevMemvar )
{
HB_VALUE_PTR pValue;
HB_HANDLE hValue; /* handle 0 is reserved */
/* = 1 removed, since it's initialized in all branches. Caused a warning with Borland C++ */
HB_TRACE(HB_TR_DEBUG, ("hb_memvarValueNew(%p, %lu)", pSource, hPrevMemvar));
if( s_globalFirstFree )
{
/* There are holes in the table - get a first available one
*/
hValue = s_globalFirstFree;
s_globalFirstFree = s_globalTable[ hValue ].hPrevMemvar;
}
else
{
/* Allocate the value from the end of table
*/
if( s_globalLastFree < s_globalTableSize )
{
hValue = s_globalLastFree++;
}
else
{
/* No more free values in the table - expand the table
*/
hValue = s_globalTableSize;
s_globalLastFree = s_globalTableSize + 1;
s_globalTableSize += TABLE_EXPANDHB_VALUE;
s_globalTable = ( HB_VALUE_PTR ) hb_xrealloc( s_globalTable, sizeof( HB_VALUE ) * s_globalTableSize );
}
}
pValue = s_globalTable + hValue;
pValue->pVarItem = ( HB_ITEM_PTR ) hb_xgrab( sizeof( HB_ITEM ) );
pValue->pVarItem->type = HB_IT_NIL;
pValue->hPrevMemvar = hPrevMemvar;
pValue->counter = 1;
if( pSource )
{
if( hPrevMemvar == ( HB_HANDLE ) -1 ) /* detached local - copy its body only */
{
memcpy( pValue->pVarItem, pSource, sizeof( HB_ITEM ) );
pValue->pVarItem->type &= ~HB_IT_DEFAULT;
}
else
{
hb_itemCopy( pValue->pVarItem, pSource );
/* Remove MEMOFLAG if exists (assignment from field). */
pValue->pVarItem->type &= ~HB_IT_MEMOFLAG;
}
}
HB_TRACE(HB_TR_INFO, ("hb_memvarValueNew: memvar item created with handle %i", hValue));
return hValue;
}
| memvars.c | 133 |
STATIC VOID | hb_memvarRecycle( HB_HANDLE hValue )
static void hb_memvarRecycle( HB_HANDLE hValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarRecycle(%lu)", hValue));
s_globalTable[ hValue ].hPrevMemvar = s_globalFirstFree;
s_globalFirstFree = hValue;
}
| memvars.c | 210 |
VOID | hb_memvarValueIncRef( HB_HANDLE hValue )
void hb_memvarValueIncRef( HB_HANDLE hValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarValueIncRef(%lu)", hValue));
s_globalTable[ hValue ].counter++;
HB_TRACE(HB_TR_INFO, ("Memvar item (%i) increment refCounter=%li", hValue, s_globalTable[ hValue ].counter));
}
| memvars.c | 218 |
VOID | hb_memvarValueDecRef( HB_HANDLE hValue )
void hb_memvarValueDecRef( HB_HANDLE hValue )
{
HB_VALUE_PTR pValue;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarValueDecRef(%lu)", hValue));
pValue = s_globalTable + hValue;
HB_TRACE(HB_TR_INFO, ("Memvar item (%i) decrement refCounter=%li", hValue, pValue->counter-1));
if( --pValue->counter == 0 )
{
if( HB_IS_COMPLEX( pValue->pVarItem ) )
hb_itemClear( pValue->pVarItem );
hb_xfree( pValue->pVarItem );
hb_memvarRecycle( hValue );
HB_TRACE(HB_TR_INFO, ("Memvar item (%i) deleted", hValue));
}
}
| memvars.c | 230 |
STATIC VOID | hb_memvarDetachDynSym( PHB_DYNS pDynSym, BOOL fRestore )
static void hb_memvarDetachDynSym( PHB_DYNS pDynSym, BOOL fRestore )
{
HB_VALUE_PTR pValue;
HB_HANDLE hValue;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarDetachDynSym(%p, %d)", pDynSym, fRestore));
hValue = pDynSym->hMemvar;
pValue = s_globalTable + hValue;
pDynSym->hMemvar = fRestore ? pValue->hPrevMemvar : 0;
if( --pValue->counter == 0 )
{
if( HB_IS_COMPLEX( pValue->pVarItem ) )
hb_itemClear( pValue->pVarItem );
hb_xfree( pValue->pVarItem );
hb_memvarRecycle( hValue );
HB_TRACE(HB_TR_INFO, ("Memvar item (%i) deleted", hValue));
}
else
{
/* memvar is still accessible by active references on HVM stack
* and/or as detached local in codeblocks - so we have to mark it
* as detached or it will be scanned in GC mark pass and if some
* cross references exists it will never be freed.
*/
pValue->hPrevMemvar = ( HB_HANDLE ) -1;
}
}
| memvars.c | 255 |
HB_ITEM_PTR | hb_memvarDetachLocal( HB_ITEM_PTR pLocal )
HB_ITEM_PTR hb_memvarDetachLocal( HB_ITEM_PTR pLocal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarDetachLocal(%p)", pLocal));
if( HB_IS_BYREF( pLocal ) )
{
do
{
if( HB_IS_MEMVAR( pLocal ) )
break;
else if( HB_IS_ENUM( pLocal ) && !pLocal->item.asEnum.valuePtr )
{
PHB_ITEM pBase = HB_IS_BYREF( pLocal->item.asEnum.basePtr ) ?
hb_itemUnRef( pLocal->item.asEnum.basePtr ) :
pLocal->item.asEnum.basePtr;
if( HB_IS_ARRAY( pBase ) )
{
PHB_ITEM pItem = hb_itemNew( NULL );
hb_arrayGetItemRef( pBase, pLocal->item.asEnum.offset, pItem );
pLocal->item.asEnum.valuePtr = pItem;
pLocal = pItem;
break;
}
}
else if( pLocal->item.asRefer.value >= 0 &&
pLocal->item.asRefer.offset == 0 )
break;
pLocal = hb_itemUnRefOnce( pLocal );
}
while( HB_IS_BYREF( pLocal ) );
}
/* Change the value only if this variable is not referenced
* by another codeblock yet.
* In this case we have to copy the current value to a global memory
* pool so it can be shared by codeblocks
*/
if( ! HB_IS_MEMVAR( pLocal ) )
{
HB_HANDLE hMemvar = hb_memvarValueNew( pLocal, ( HB_HANDLE ) -1 );
pLocal->type = HB_IT_BYREF | HB_IT_MEMVAR;
pLocal->item.asMemvar.itemsbase = &s_globalTable;
pLocal->item.asMemvar.value = hMemvar;
}
return pLocal;
}
| memvars.c | 289 |
STATIC VOID | hb_memvarAddPrivate( PHB_DYNS pDynSym )
static void hb_memvarAddPrivate( PHB_DYNS pDynSym )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarAddPrivate(%p)", pDynSym));
/* Allocate the value from the end of table
*/
if( s_privateStackCnt == s_privateStackSize )
{
/* No more free values in the table - expand the table
*/
s_privateStackSize += TABLE_EXPANDHB_VALUE;
s_privateStack = ( PHB_DYNS * ) hb_xrealloc( s_privateStack, sizeof( PHB_DYNS ) * s_privateStackSize );
}
s_privateStack[ s_privateStackCnt++ ] = pDynSym;
}
| memvars.c | 341 |
ULONG | hb_memvarGetPrivatesBase( void )
ULONG hb_memvarGetPrivatesBase( void )
{
ULONG ulBase = s_privateStackBase;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetPrivatesBase()"));
s_privateStackBase = s_privateStackCnt;
return ulBase;
}
| memvars.c | 365 |
VOID | hb_memvarSetPrivatesBase( ULONG ulBase )
void hb_memvarSetPrivatesBase( ULONG ulBase )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarSetPrivatesBase(%lu)", ulBase));
while( s_privateStackCnt > s_privateStackBase )
{
if( s_privateStack[ --s_privateStackCnt ]->hMemvar )
{
/* Restore previous value for variables that were overridden
*/
hb_memvarDetachDynSym( s_privateStack[ s_privateStackCnt ], TRUE );
}
}
s_privateStackBase = ulBase;
}
| memvars.c | 378 |
VOID | hb_memvarUpdatePrivatesBase( void )
void hb_memvarUpdatePrivatesBase( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarUpdatePrivatesBase()"));
s_privateStackBase = s_privateStackCnt;
}
| memvars.c | 397 |
VOID | hb_memvarSetValue( PHB_SYMB pMemvarSymb, HB_ITEM_PTR pItem )
void hb_memvarSetValue( PHB_SYMB pMemvarSymb, HB_ITEM_PTR pItem )
{
PHB_DYNS pDyn;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarSetValue(%p, %p)", pMemvarSymb, pItem));
pDyn = ( PHB_DYNS ) pMemvarSymb->pDynSym;
if( pDyn )
{
HB_TRACE(HB_TR_INFO, ("Memvar item (%i)(%s) assigned", pDyn->hMemvar, pMemvarSymb->szName));
if( pDyn->hMemvar )
{
/* value is already created */
hb_itemCopyToRef( s_globalTable[ pDyn->hMemvar ].pVarItem, pItem );
/* Remove MEMOFLAG if exists (assignment from field). */
s_globalTable[ pDyn->hMemvar ].pVarItem->type &= ~HB_IT_MEMOFLAG;
}
else
{
/* assignment to undeclared memvar - PRIVATE is assumed */
hb_memvarCreateFromDynSymbol( pDyn, VS_PRIVATE, pItem );
}
}
else
hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL );
}
| memvars.c | 408 |
ERRCODE | hb_memvarGet( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
ERRCODE hb_memvarGet( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
{
PHB_DYNS pDyn;
ERRCODE bSuccess = FAILURE;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGet(%p, %p)", pItem, pMemvarSymb));
pDyn = ( PHB_DYNS ) pMemvarSymb->pDynSym;
if( pDyn )
{
HB_TRACE(HB_TR_INFO, ("Memvar item (%i)(%s) queried", pDyn->hMemvar, pMemvarSymb->szName));
if( pDyn->hMemvar )
{
/* value is already created
*/
HB_ITEM_PTR pGetItem = s_globalTable[ pDyn->hMemvar ].pVarItem;
if( HB_IS_BYREF( pGetItem ) )
hb_itemCopy( pItem, hb_itemUnRef( pGetItem ) );
else
hb_itemCopy( pItem, pGetItem );
bSuccess = SUCCESS;
}
}
else
hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL );
return bSuccess;
}
| memvars.c | 446 |
VOID | hb_memvarGetValue( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
void hb_memvarGetValue( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetValue(%p, %p)", pItem, pMemvarSymb));
if( hb_memvarGet( pItem, pMemvarSymb ) == FAILURE )
{
/* Generate an error with retry possibility
* (user created error handler can create this variable)
*/
HB_ITEM_PTR pError;
pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, 1003,
NULL, pMemvarSymb->szName, 0, EF_CANRETRY );
while( hb_errLaunch( pError ) == E_RETRY )
{
if( hb_memvarGet( pItem, pMemvarSymb ) == SUCCESS )
break;
}
hb_errRelease( pError );
}
}
| memvars.c | 476 |
VOID | hb_memvarGetRefer( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
void hb_memvarGetRefer( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
{
PHB_DYNS pDyn;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetRefer(%p, %p)", pItem, pMemvarSymb));
pDyn = ( PHB_DYNS ) pMemvarSymb->pDynSym;
if( pDyn )
{
HB_TRACE(HB_TR_INFO, ("Memvar item (%i)(%s) referenced", pDyn->hMemvar, pMemvarSymb->szName));
if( pDyn->hMemvar )
{
PHB_ITEM pMemvar = s_globalTable[ pDyn->hMemvar ].pVarItem;
if( HB_IS_BYREF( pMemvar ) )
hb_itemCopy( pItem, pMemvar );
else
{
/* value is already created */
pItem->type = HB_IT_BYREF | HB_IT_MEMVAR;
pItem->item.asMemvar.value = pDyn->hMemvar;
pItem->item.asMemvar.itemsbase = &s_globalTable;
++s_globalTable[ pDyn->hMemvar ].counter;
}
}
else
{
/* Generate an error with retry possibility
* (user created error handler can make this variable accessible)
*/
HB_ITEM_PTR pError;
pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, 1003,
NULL, pMemvarSymb->szName, 0, EF_CANRETRY );
while( hb_errLaunch( pError ) == E_RETRY )
{
if( pDyn->hMemvar )
{
PHB_ITEM pMemvar = s_globalTable[ pDyn->hMemvar ].pVarItem;
if( HB_IS_BYREF( pMemvar ) )
hb_itemCopy( pItem, pMemvar );
else
{
/* value is already created */
pItem->type = HB_IT_BYREF | HB_IT_MEMVAR;
pItem->item.asMemvar.value = pDyn->hMemvar;
pItem->item.asMemvar.itemsbase = &s_globalTable;
++s_globalTable[ pDyn->hMemvar ].counter;
}
break;
}
}
hb_errRelease( pError );
}
}
else
hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL );
}
| memvars.c | 500 |
PHB_ITEM | hb_memvarGetItem( PHB_SYMB pMemvarSymb )
PHB_ITEM hb_memvarGetItem( PHB_SYMB pMemvarSymb )
{
PHB_DYNS pDyn;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetItem(%p)", pMemvarSymb));
pDyn = ( PHB_DYNS ) pMemvarSymb->pDynSym;
if( pDyn && pDyn->hMemvar )
{
HB_ITEM_PTR pItem = s_globalTable[ pDyn->hMemvar ].pVarItem;
if( HB_IS_BYREF( pItem ) )
return hb_itemUnRef( pItem );
else
return pItem;
}
return NULL;
}
| memvars.c | 560 |
VOID | hb_memvarNewParameter( PHB_SYMB pSymbol, PHB_ITEM pValue )
void hb_memvarNewParameter( PHB_SYMB pSymbol, PHB_ITEM pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarNewParameter(%p, %p)", pSymbol, pValue));
hb_memvarCreateFromDynSymbol( pSymbol->pDynSym, VS_PRIVATE, pValue );
}
| memvars.c | 578 |
STATIC HB_DYNS_PTR | hb_memvarFindSymbol( char * szArg, ULONG ulLen )
static HB_DYNS_PTR hb_memvarFindSymbol( char * szArg, ULONG ulLen )
{
HB_DYNS_PTR pDynSym = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarFindSymbol(%p,%lu)", szArg, ulLen));
if( ulLen && szArg && *szArg )
{
char szUprName[ HB_SYMBOL_NAME_LEN + 1 ];
int iSize = 0;
do
{
char cChar = *szArg++;
if( cChar >= 'a' && cChar <= 'z' )
{
szUprName[ iSize++ ] = cChar - ( 'a' - 'A' );
}
else if( cChar == ' ' || cChar == '\t' || cChar == '\n' )
{
if( iSize )
break;
}
else if( !cChar )
{
break;
}
else
{
szUprName[ iSize++ ] = cChar;
}
}
while( --ulLen && iSize < HB_SYMBOL_NAME_LEN );
if( iSize )
{
szUprName[ iSize ] = '\0';
pDynSym = hb_dynsymFind( szUprName );
}
}
return pDynSym;
}
| memvars.c | 587 |
CHAR * | hb_memvarGetStrValuePtr( char * szVarName, ULONG *pulLen )
char * hb_memvarGetStrValuePtr( char * szVarName, ULONG *pulLen )
{
HB_DYNS_PTR pDynVar;
char * szValue = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetStrValuePtr(%s, %li)", szVarName, pulLen));
pDynVar = hb_memvarFindSymbol( szVarName, *pulLen );
if( pDynVar )
{
/* there is dynamic symbol with the requested name - check if it is
* a memvar variable
*/
if( pDynVar->hMemvar )
{
/* variable contains some data
*/
HB_ITEM_PTR pItem = s_globalTable[ pDynVar->hMemvar ].pVarItem;
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem ); /* it is a PARAMETER variable */
if( HB_IS_STRING( pItem ) )
{
szValue = pItem->item.asString.value;
*pulLen = pItem->item.asString.length;
}
}
}
return szValue;
}
| memvars.c | 631 |
VOID | hb_memvarCreateFromItem( PHB_ITEM pMemvar, BYTE bScope, PHB_ITEM pValue )
void hb_memvarCreateFromItem( PHB_ITEM pMemvar, BYTE bScope, PHB_ITEM pValue )
{
PHB_DYNS pDynVar = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarCreateFromItem(%p, %d, %p)", pMemvar, bScope, pValue));
/* find dynamic symbol or creeate one */
if( HB_IS_SYMBOL( pMemvar ) )
/* pDynVar = hb_dynsymGet( pMemvar->item.asSymbol.value->szName ); */
pDynVar = pMemvar->item.asSymbol.value->pDynSym;
else if( HB_IS_STRING( pMemvar ) )
pDynVar = hb_dynsymGet( pMemvar->item.asString.value );
if( pDynVar )
hb_memvarCreateFromDynSymbol( pDynVar, bScope, pValue );
else
hb_errRT_BASE( EG_ARG, 3008, NULL, "&", HB_ERR_ARGS_BASEPARAMS );
}
| memvars.c | 663 |
STATIC VOID | hb_memvarCreateFromDynSymbol( PHB_DYNS pDynVar, BYTE bScope, PHB_ITEM pValue )
static void hb_memvarCreateFromDynSymbol( PHB_DYNS pDynVar, BYTE bScope, PHB_ITEM pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarCreateFromDynSymbol(%p, %d, %p)", pDynVar, bScope, pValue));
if( bScope & VS_PUBLIC )
{
/* If the variable with the same name exists already
* then the current value have to be unchanged
*/
if( ! pDynVar->hMemvar )
{
pDynVar->hMemvar = hb_memvarValueNew( pValue, 0 );
if( !pValue )
{
/* new PUBLIC variable - initialize it to .F.
*/
s_globalTable[ pDynVar->hMemvar ].pVarItem->type = HB_IT_LOGICAL;
/* NOTE: PUBLIC variables named CLIPPER and HARBOUR are initialized */
/* to .T., this is normal Clipper behaviour. [vszakats] */
if( strcmp( pDynVar->pSymbol->szName, "HARBOUR" ) == 0 ||
strcmp( pDynVar->pSymbol->szName, "CLIPPER" ) == 0 )
s_globalTable[ pDynVar->hMemvar ].pVarItem->item.asLogical.value = TRUE;
else
s_globalTable[ pDynVar->hMemvar ].pVarItem->item.asLogical.value = FALSE;
}
}
}
else
{
/* We need to store the handle to the value of variable that is
* visible at this moment so later we can restore this value when
* the new variable will be released
*/
pDynVar->hMemvar = hb_memvarValueNew( pValue, pDynVar->hMemvar );
/* Add this variable to the PRIVATE variables stack
*/
hb_memvarAddPrivate( pDynVar );
}
}
| memvars.c | 695 |
STATIC VOID | hb_memvarRelease( HB_ITEM_PTR pMemvar )
static void hb_memvarRelease( HB_ITEM_PTR pMemvar )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarRelease(%p)", pMemvar));
if( HB_IS_STRING( pMemvar ) )
{
PHB_DYNS pDynSymbol = hb_memvarFindSymbol( pMemvar->item.asString.value,
pMemvar->item.asString.length );
if( pDynSymbol && pDynSymbol->hMemvar )
{
ULONG ulBase = s_privateStackCnt;
/* Find the variable with a requested name that is currently visible
* Start from the top of the stack.
*/
while( ulBase > 0 )
{
if( pDynSymbol == s_privateStack[ --ulBase ] )
{
/* reset current value to NIL - the overriden variables will be
* visible after exit from current procedure
*/
hb_itemClear( s_globalTable[ pDynSymbol->hMemvar ].pVarItem );
return;
}
}
/* No match found for PRIVATEs - it's PUBLIC so let's remove it.
*/
hb_memvarDetachDynSym( pDynSymbol, FALSE );
}
}
else
hb_errRT_BASE( EG_ARG, 3008, NULL, "RELEASE", HB_ERR_ARGS_BASEPARAMS );
}
| memvars.c | 739 |
STATIC VOID | hb_memvarReleaseWithMask( char *szMask, BOOL bInclude )
static void hb_memvarReleaseWithMask( char *szMask, BOOL bInclude )
{
ULONG ulBase = s_privateStackCnt;
PHB_DYNS pDynVar;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarReleaseWithMask(%s, %d)", szMask, (int) bInclude));
while( ulBase > s_privateStackBase )
{
--ulBase;
pDynVar = s_privateStack[ ulBase ];
/* reset current value to NIL - the overriden variables will be
* visible after exit from current procedure
*/
if( pDynVar->hMemvar )
{
BOOL fMatch = hb_strMatchCaseWildExact( pDynVar->pSymbol->szName, szMask );
if( bInclude ? fMatch : !fMatch )
hb_itemClear( s_globalTable[ pDynVar->hMemvar ].pVarItem );
}
}
}
| memvars.c | 781 |
STATIC INT | hb_memvarScopeGet( PHB_DYNS pDynVar )
static int hb_memvarScopeGet( PHB_DYNS pDynVar )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarScopeGet(%p)", pDynVar));
if( pDynVar->hMemvar == 0 )
return HB_MV_UNKNOWN;
else
{
ULONG ulBase = s_privateStackCnt; /* start from the top of the stack */
while( ulBase )
{
if( pDynVar == s_privateStack[ --ulBase ] )
{
if( ulBase >= s_privateStackBase )
return HB_MV_PRIVATE_LOCAL;
else
return HB_MV_PRIVATE_GLOBAL;
}
}
return HB_MV_PUBLIC;
}
}
| memvars.c | 809 |
INT | hb_memvarScope( char * szVarName, ULONG ulLength )
int hb_memvarScope( char * szVarName, ULONG ulLength )
{
PHB_DYNS pDynVar;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarScope(%s, %lu)", szVarName, ulLength));
pDynVar = hb_memvarFindSymbol( szVarName, ulLength );
if( pDynVar )
return hb_memvarScopeGet( pDynVar );
else
return HB_MV_NOT_FOUND;
}
| memvars.c | 835 |
STATIC HB_DYNS_FUNC( | hb_memvarClear )
static HB_DYNS_FUNC( hb_memvarClear )
{
HB_SYMBOL_UNUSED( Cargo );
if( pDynSymbol->hMemvar )
hb_memvarDetachDynSym( pDynSymbol, FALSE );
return TRUE;
}
| memvars.c | 851 |
VOID | hb_memvarsClear( void )
void hb_memvarsClear( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarsClear()"));
hb_stackClearMevarsBase();
s_privateStackBase = 0;
hb_memvarSetPrivatesBase( 0 );
hb_dynsymEval( hb_memvarClear, NULL );
}
| memvars.c | 863 |
STATIC HB_DYNS_FUNC( | hb_memvarCountPublics )
static HB_DYNS_FUNC( hb_memvarCountPublics )
{
if( hb_memvarScopeGet( pDynSymbol ) == HB_MV_PUBLIC )
( * ( ( int * )Cargo ) )++;
return TRUE;
}
| memvars.c | 874 |
STATIC INT | hb_memvarCount( int iScope )
static int hb_memvarCount( int iScope )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarCount(%d)", iScope));
if( iScope == HB_MV_PUBLIC )
{
int iPublicCnt = 0;
hb_dynsymEval( hb_memvarCountPublics, ( void * ) &iPublicCnt );
return iPublicCnt;
}
else
return s_privateStackCnt; /* number of PRIVATE variables */
}
| memvars.c | 885 |
STATIC HB_DYNS_FUNC( | hb_memvarFindPublicByPos )
static HB_DYNS_FUNC( hb_memvarFindPublicByPos )
{
BOOL bCont = TRUE;
if( hb_memvarScopeGet( pDynSymbol ) == HB_MV_PUBLIC )
{
struct mv_PUBLIC_var_info *pStruPub = (struct mv_PUBLIC_var_info *) Cargo;
if( pStruPub->iPos-- == 0 )
{
pStruPub->bFound = TRUE;
pStruPub->pDynSym = pDynSymbol;
bCont =FALSE;
}
}
return bCont;
}
| memvars.c | 902 |
STATIC HB_ITEM_PTR | hb_memvarDebugVariable( int iScope, int iPos, const char * * pszName )
static HB_ITEM_PTR hb_memvarDebugVariable( int iScope, int iPos, const char * * pszName )
{
HB_ITEM_PTR pValue = NULL;
*pszName = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarDebugVariable(%d, %d, %p)", iScope, iPos, pszName));
if( iPos > 0 )
{
--iPos;
if( iScope == HB_MV_PUBLIC )
{
struct mv_PUBLIC_var_info struPub;
struPub.iPos = iPos;
struPub.bFound = FALSE;
/* enumerate existing dynamic symbols and fill this structure
* with info for requested PUBLIC variable
*/
hb_dynsymEval( hb_memvarFindPublicByPos, ( void * ) &struPub );
if( struPub.bFound )
{
pValue = s_globalTable[ struPub.pDynSym->hMemvar ].pVarItem;
*pszName = struPub.pDynSym->pSymbol->szName;
}
}
else
{
if( ( ULONG ) iPos < s_privateStackCnt )
{
HB_DYNS_PTR pDynSym = s_privateStack[ iPos ];
pValue =s_globalTable[ pDynSym->hMemvar ].pVarItem;
*pszName = pDynSym->pSymbol->szName;
}
}
}
return pValue;
}
| memvars.c | 923 |
STATIC CHAR * | hb_memvarGetMask( int iParam )
static char * hb_memvarGetMask( int iParam )
{
char * pszMask = hb_parc( iParam );
if( !pszMask || pszMask[ 0 ] == '*' )
pszMask = "*";
return pszMask;
}
| memvars.c | 971 |
HB_FUNC | __MVPUBLIC(void)
HB_FUNC( __MVPUBLIC )
{
int iCount = hb_pcount();
if( iCount )
{
int i;
for( i = 1; i <= iCount; i++ )
{
PHB_ITEM pMemvar = hb_param( i, HB_IT_ANY );
if( pMemvar )
{
if( HB_IS_ARRAY( pMemvar ) )
{
/* we are accepting an one-dimensional array of strings only
*/
ULONG j, ulLen = hb_arrayLen( pMemvar );
for( j = 1; j <= ulLen; j++ )
{
hb_memvarCreateFromItem( hb_arrayGetItemPtr( pMemvar, j ), VS_PUBLIC, NULL );
}
}
else
hb_memvarCreateFromItem( pMemvar, VS_PUBLIC, NULL );
}
}
}
}
| memvars.c | 979 |
HB_FUNC | __MVPRIVATE(void)
HB_FUNC( __MVPRIVATE )
{
int iCount = hb_pcount();
if( iCount )
{
int i;
for( i = 1; i <= iCount; i++ )
{
PHB_ITEM pMemvar = hb_param( i, HB_IT_ANY );
if( pMemvar )
{
if( HB_IS_ARRAY( pMemvar ) )
{
/* we are accepting an one-dimensional array of strings only
*/
ULONG j, ulLen = hb_arrayLen( pMemvar );
for( j = 1; j <= ulLen; j++ )
{
hb_memvarCreateFromItem( hb_arrayGetItemPtr( pMemvar, j ), VS_PRIVATE, NULL );
}
}
else
hb_memvarCreateFromItem( pMemvar, VS_PRIVATE, NULL );
}
}
hb_memvarUpdatePrivatesBase();
}
}
| memvars.c | 1011 |
HB_FUNC | __MVXRELEASE(void)
HB_FUNC( __MVXRELEASE )
{
int iCount = hb_pcount();
if( iCount )
{
int i;
for( i = 1; i <= iCount; i++ )
{
PHB_ITEM pMemvar = hb_param( i, HB_IT_ANY );
if( pMemvar )
{
if( HB_IS_ARRAY( pMemvar ) )
{
/* we are accepting an one-dimensional array of strings only
*/
ULONG j, ulLen = hb_arrayLen( pMemvar );
for( j = 1; j <= ulLen; j++ )
{
hb_memvarRelease( hb_arrayGetItemPtr( pMemvar, j ) );
}
}
else
hb_memvarRelease( pMemvar );
}
}
}
}
| memvars.c | 1044 |
HB_FUNC | __MVRELEASE(void)
HB_FUNC( __MVRELEASE )
{
int iCount = hb_pcount();
if( iCount && ISCHAR( 1 ) )
{
BOOL bIncludeVar;
char * pszMask;
pszMask = hb_memvarGetMask( 1 );
bIncludeVar = ( pszMask[ 0 ] == '*' && !pszMask[ 1 ] ) ||
iCount < 2 || hb_parl( 2 );
hb_memvarReleaseWithMask( pszMask, bIncludeVar );
}
}
| memvars.c | 1076 |
HB_FUNC | __MVSCOPE(void)
HB_FUNC( __MVSCOPE )
{
int iMemvar = HB_MV_ERROR;
if( hb_pcount() )
{
PHB_ITEM pVarName = hb_param( 1, HB_IT_STRING );
if( pVarName )
iMemvar = hb_memvarScope( pVarName->item.asString.value,
pVarName->item.asString.length );
}
hb_retni( iMemvar );
}
| memvars.c | 1092 |
HB_FUNC | __MVCLEAR(void)
HB_FUNC( __MVCLEAR )
{
hb_memvarsClear();
}
| memvars.c | 1108 |
HB_FUNC | __MVDBGINFO(void)
HB_FUNC( __MVDBGINFO )
{
int iCount = hb_pcount();
if( iCount == 1 ) /* request for a number of variables */
hb_retni( hb_memvarCount( hb_parni( 1 ) ) );
else if( iCount >= 2 ) /* request for a value of variable */
{
HB_ITEM_PTR pValue;
const char * szName;
pValue = hb_memvarDebugVariable( hb_parni( 1 ), hb_parni( 2 ), &szName );
if( pValue )
{
/*the requested variable was found
*/
if( iCount >= 3 && ISBYREF( 3 ) )
{
/* we have to use this variable regardless of its current value
*/
HB_ITEM_PTR pName = hb_param( 3, HB_IT_ANY );
hb_itemPutC( pName, szName ); /* clear an old value and copy a new one */
/* szName points directly to a symbol name - it cannot be released
*/
}
hb_itemReturn( pValue );
/* pValue points directly to the item structure used by this variable
* this item cannot be released
*/
}
else
{
hb_ret(); /* return NIL value */
if( iCount >= 3 && ISBYREF( 3 ) )
{
/* we have to use this variable regardless of its current value
*/
HB_ITEM_PTR pName = hb_param( 3, HB_IT_ANY );
hb_itemPutC( pName, "?" ); /* clear an old value and copy a new one */
}
}
}
}
| memvars.c | 1113 |
HB_FUNC | __MVEXIST(void)
HB_FUNC( __MVEXIST )
{
PHB_DYNS pDyn;
pDyn = hb_memvarFindSymbol( hb_parc( 1 ), hb_parclen( 1 ) );
hb_retl( pDyn && pDyn->hMemvar );
}
| memvars.c | 1162 |
HB_FUNC | __MVGET(void)
HB_FUNC( __MVGET )
{
HB_ITEM_PTR pName = hb_param( 1, HB_IT_STRING );
if( pName )
{
HB_DYNS_PTR pDynVar = hb_memvarFindSymbol( pName->item.asString.value,
pName->item.asString.length );
if( pDynVar )
{
PHB_ITEM pValue = hb_stackAllocItem();
hb_memvarGetValue( pValue, pDynVar->pSymbol );
hb_itemReturnForward( pValue );
hb_stackDec();
}
else
{
/* Generate an error with retry possibility
* (user created error handler can create this variable)
*/
HB_ITEM_PTR pError;
pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, 1003,
NULL, pName->item.asString.value, 0, EF_CANRETRY );
while( hb_errLaunch( pError ) == E_RETRY )
{
pDynVar = hb_memvarFindSymbol( hb_itemGetCPtr( pName ),
hb_itemGetCLen( pName ) );
if( pDynVar )
{
PHB_ITEM pValue = hb_stackAllocItem();
hb_memvarGetValue( pValue, pDynVar->pSymbol );
hb_itemReturnForward( pValue );
hb_stackDec();
break;
}
}
hb_errRelease( pError );
}
}
else
{
/* either the first parameter is not specified or it has a wrong type
* (it must be a string)
* This is not a critical error - we can continue normal processing
*/
hb_errRT_BASE_SubstR( EG_ARG, 3009, NULL, NULL, HB_ERR_ARGS_BASEPARAMS );
}
}
| memvars.c | 1169 |
HB_FUNC | __MVPUT(void)
HB_FUNC( __MVPUT )
{
HB_ITEM_PTR pName = hb_param( 1, HB_IT_STRING );
HB_ITEM_PTR pValue = hb_paramError( 2 );
if( pName )
{
/* the first parameter is a string with not empty variable name
*/
HB_DYNS_PTR pDynVar = hb_memvarFindSymbol( pName->item.asString.value,
pName->item.asString.length );
if( pDynVar )
{
/* variable was declared somwhere - assign a new value
*/
hb_memvarSetValue( pDynVar->pSymbol, pValue );
}
else
{
/* attempt to assign a value to undeclared variable
* create the PRIVATE one
*/
hb_memvarCreateFromDynSymbol( hb_dynsymGet( pName->item.asString.value ), VS_PRIVATE, pValue );
}
hb_memvarUpdatePrivatesBase();
hb_itemReturn( pValue );
}
else
{
/* either the first parameter is not specified or it has a wrong type
* (it must be a string)
* This is not a critical error - we can continue normal processing
*/
HB_ITEM_PTR pRetValue = hb_errRT_BASE_Subst( EG_ARG, 3010, NULL, NULL, HB_ERR_ARGS_BASEPARAMS );
if( pRetValue )
hb_itemRelease( pRetValue );
hb_itemReturn( pValue );
}
}
#define HB_MEM_REC_LEN 32
#define HB_MEM_NUM_LEN 8
typedef struct
{
char * pszMask;
BOOL bIncludeMask;
BYTE * buffer;
FHANDLE fhnd;
} MEMVARSAVE_CARGO;
| memvars.c | 1223 |
STATIC HB_DYNS_FUNC( | hb_memvarSave )
static HB_DYNS_FUNC( hb_memvarSave )
{
char * pszMask = ( ( MEMVARSAVE_CARGO * ) Cargo )->pszMask;
BOOL bIncludeMask = ( ( MEMVARSAVE_CARGO * ) Cargo )->bIncludeMask;
BYTE * buffer = ( ( MEMVARSAVE_CARGO * ) Cargo )->buffer;
FHANDLE fhnd = ( ( MEMVARSAVE_CARGO * ) Cargo )->fhnd;
/* NOTE: Harbour name lengths are not limited, but the .mem file
structure is not flexible enough to allow for it.
[vszakats] */
if( pDynSymbol->hMemvar )
{
BOOL bMatch = hb_strMatchCaseWildExact( pDynSymbol->pSymbol->szName, pszMask );
PHB_ITEM pItem = s_globalTable[ pDynSymbol->hMemvar ].pVarItem;
/* Process it if it matches the passed mask */
if( bIncludeMask ? bMatch : ! bMatch )
{
/* NOTE: Clipper will not initialize the record buffer with
zeros, so they will look trashed. [vszakats] */
memset( buffer, 0, HB_MEM_REC_LEN );
/* NOTE: Save only the first 10 characters of the name */
strncpy( ( char * ) buffer, pDynSymbol->pSymbol->szName, 10 );
buffer[ 10 ] = '\0';
if( HB_IS_STRING( pItem ) && ( hb_itemGetCLen( pItem ) + 1 ) <= SHRT_MAX )
{
/* Store the closing zero byte, too */
USHORT uiLength = ( USHORT ) ( hb_itemGetCLen( pItem ) + 1 );
buffer[ 11 ] = 'C' + 128;
buffer[ 16 ] = HB_LOBYTE( uiLength );
buffer[ 17 ] = HB_HIBYTE( uiLength );
hb_fsWrite( fhnd, buffer, HB_MEM_REC_LEN );
hb_fsWrite( fhnd, ( BYTE * ) hb_itemGetCPtr( pItem ), uiLength );
}
else if( HB_IS_NUMERIC( pItem ) )
{
BYTE byNum[ sizeof( double ) ];
int iWidth;
int iDec;
hb_itemGetNLen( pItem, &iWidth, &iDec );
buffer[ 11 ] = 'N' + 128;
#ifdef HB_C52_STRICT
/* NOTE: This is the buggy, but fully CA-Cl*pper compatible method. [vszakats] */
buffer[ 16 ] = ( BYTE ) iWidth + ( HB_IS_DOUBLE( pItem ) ? iDec + 1 : 0 );
#else
/* NOTE: This would be the correct method, but Clipper is buggy here. [vszakats] */
buffer[ 16 ] = ( BYTE ) iWidth + ( iDec == 0 ? 0 : iDec + 1 );
#endif
buffer[ 17 ] = ( BYTE ) iDec;
HB_PUT_LE_DOUBLE( byNum, hb_itemGetND( pItem ) );
hb_fsWrite( fhnd, buffer, HB_MEM_REC_LEN );
hb_fsWrite( fhnd, byNum, sizeof( byNum ) );
}
else if( HB_IS_DATE( pItem ) )
{
BYTE byNum[ sizeof( double ) ];
double dNumber = ( double ) hb_itemGetDL( pItem );
buffer[ 11 ] = 'D' + 128;
buffer[ 16 ] = 1;
buffer[ 17 ] = 0;
HB_PUT_LE_DOUBLE( byNum, dNumber );
hb_fsWrite( fhnd, buffer, HB_MEM_REC_LEN );
hb_fsWrite( fhnd, byNum, sizeof( byNum ) );
}
else if( HB_IS_LOGICAL( pItem ) )
{
BYTE byLogical[ 1 ];
buffer[ 11 ] = 'L' + 128;
buffer[ 16 ] = sizeof( BYTE );
buffer[ 17 ] = 0;
byLogical[ 0 ] = hb_itemGetL( pItem ) ? 1 : 0;
hb_fsWrite( fhnd, buffer, HB_MEM_REC_LEN );
hb_fsWrite( fhnd, byLogical, sizeof( BYTE ) );
}
}
}
return TRUE;
}
| memvars.c | 1277 |
HB_FUNC | __MVSAVE(void)
HB_FUNC( __MVSAVE )
{
/* Clipper also checks for the number of arguments here */
if( hb_pcount() == 3 && ISCHAR( 1 ) && ISCHAR( 2 ) && ISLOG( 3 ) )
{
PHB_FNAME pFileName;
char szFileName[ _POSIX_PATH_MAX + 1 ];
FHANDLE fhnd;
/* Generate filename */
pFileName = hb_fsFNameSplit( hb_parc( 1 ) );
if( hb_set.HB_SET_DEFEXTENSIONS && pFileName->szExtension == NULL )
pFileName->szExtension = ".mem";
if( pFileName->szPath == NULL )
pFileName->szPath = hb_set.HB_SET_DEFAULT;
hb_fsFNameMerge( szFileName, pFileName );
hb_xfree( pFileName );
/* Create .mem file */
do
{
fhnd = hb_fsCreate( ( BYTE * ) szFileName, FC_NORMAL );
}
#ifdef HB_C52_STRICT
while( fhnd == FS_ERROR &&
hb_errRT_BASE_Ext1( EG_CREATE, 2006, NULL, szFileName,
hb_fsError(), EF_CANDEFAULT | EF_CANRETRY,
0 ) == E_RETRY );
#else
while( fhnd == FS_ERROR &&
hb_errRT_BASE_Ext1( EG_CREATE, 2006, NULL, szFileName,
hb_fsError(), EF_CANDEFAULT | EF_CANRETRY,
HB_ERR_ARGS_BASEPARAMS ) == E_RETRY );
#endif
if( fhnd != FS_ERROR )
{
BYTE buffer[ HB_MEM_REC_LEN ];
MEMVARSAVE_CARGO msc;
msc.pszMask = hb_memvarGetMask( 2 );
msc.bIncludeMask = hb_parl( 3 );
msc.buffer = buffer;
msc.fhnd = fhnd;
/* Walk through all visible memory variables and save each one */
hb_dynsymEval( hb_memvarSave, ( void * ) &msc );
buffer[ 0 ] = '\x1A';
hb_fsWrite( fhnd, buffer, 1 );
hb_fsClose( fhnd );
}
}
else
/* NOTE: Undocumented error message in CA-Cl*pper 5.2e and 5.3x. [ckedem] */
hb_errRT_BASE( EG_ARG, 2008, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| memvars.c | 1372 |
HB_FUNC | __MVRESTORE(void)
HB_FUNC( __MVRESTORE )
{
/* Clipper checks for the number of arguments here here, but we cannot
in Harbour since we have two optional parameters as an extension. */
#ifdef HB_C52_STRICT
if( hb_pcount() == 2 && ISCHAR( 1 ) && ISLOG( 2 ) )
#else
if( ISCHAR( 1 ) && ISLOG( 2 ) )
#endif
{
PHB_FNAME pFileName;
char szFileName[ _POSIX_PATH_MAX + 1 ];
FHANDLE fhnd;
BOOL bAdditive = hb_parl( 2 );
/* Clear all memory variables if not ADDITIVE */
if( ! bAdditive )
hb_memvarsClear();
/* Generate filename */
pFileName = hb_fsFNameSplit( hb_parc( 1 ) );
if( hb_set.HB_SET_DEFEXTENSIONS && pFileName->szExtension == NULL )
pFileName->szExtension = ".mem";
if( pFileName->szPath == NULL )
pFileName->szPath = hb_set.HB_SET_DEFAULT;
hb_fsFNameMerge( szFileName, pFileName );
hb_xfree( pFileName );
/* Open .mem file */
do
{
fhnd = hb_fsOpen( ( BYTE * ) szFileName, FO_READ | FO_DENYWRITE | FO_PRIVATE );
}
#ifdef HB_C52_STRICT
while( fhnd == FS_ERROR &&
hb_errRT_BASE_Ext1( EG_OPEN, 2005, NULL, szFileName,
hb_fsError(), EF_CANDEFAULT | EF_CANRETRY,
0 ) == E_RETRY );
#else
while( fhnd == FS_ERROR &&
hb_errRT_BASE_Ext1( EG_OPEN, 2005, NULL, szFileName,
hb_fsError(), EF_CANDEFAULT | EF_CANRETRY,
HB_ERR_ARGS_BASEPARAMS ) == E_RETRY );
#endif
if( fhnd != FS_ERROR )
{
BOOL bIncludeMask;
BYTE buffer[ HB_MEM_REC_LEN ];
char * pszMask;
#ifdef HB_C52_STRICT
pszMask = "*";
bIncludeMask = TRUE;
#else
pszMask = hb_memvarGetMask( 3 );
bIncludeMask = !ISLOG( 4 ) || hb_parl( 4 );
#endif
while( hb_fsRead( fhnd, buffer, HB_MEM_REC_LEN ) == HB_MEM_REC_LEN )
{
char *szName = hb_strdup( ( char * ) buffer );
USHORT uiType = ( USHORT ) ( buffer[ 11 ] - 128 );
USHORT uiWidth = ( USHORT ) buffer[ 16 ];
USHORT uiDec = ( USHORT ) buffer[ 17 ];
PHB_ITEM pItem = NULL;
switch( uiType )
{
case 'C':
{
BYTE * pbyString;
uiWidth += uiDec * 256;
pbyString = ( BYTE * ) hb_xgrab( uiWidth );
if( hb_fsRead( fhnd, pbyString, uiWidth ) == uiWidth )
pItem = hb_itemPutCL( NULL, ( char * ) pbyString, uiWidth - 1 );
hb_xfree( pbyString );
break;
}
case 'N':
{
BYTE pbyNumber[ HB_MEM_NUM_LEN ];
if( hb_fsRead( fhnd, pbyNumber, HB_MEM_NUM_LEN ) == HB_MEM_NUM_LEN )
pItem = hb_itemPutNLen( NULL, HB_GET_LE_DOUBLE( pbyNumber ), uiWidth - ( uiDec ? ( uiDec + 1 ) : 0 ), uiDec );
break;
}
case 'D':
{
BYTE pbyNumber[ HB_MEM_NUM_LEN ];
if( hb_fsRead( fhnd, pbyNumber, HB_MEM_NUM_LEN ) == HB_MEM_NUM_LEN )
pItem = hb_itemPutDL( NULL, ( long ) HB_GET_LE_DOUBLE( pbyNumber ) );
break;
}
case 'L':
{
BYTE pbyLogical[ 1 ];
if( hb_fsRead( fhnd, pbyLogical, 1 ) == 1 )
pItem = hb_itemPutL( NULL, pbyLogical[ 0 ] != 0 );
break;
}
}
if( pItem )
{
BOOL bMatch = hb_strMatchCaseWildExact( szName, pszMask );
/* Process it if it matches the passed mask */
if( bIncludeMask ? bMatch : ! bMatch )
{
/* the first parameter is a string with not empty variable name */
HB_DYNS_PTR pDynVar = hb_memvarFindSymbol( szName, strlen( szName ) );
if( pDynVar )
/* variable was declared somwhere - assign a new value */
hb_memvarSetValue( pDynVar->pSymbol, pItem );
else
/* attempt to assign a value to undeclared variable create the PRIVATE one */
hb_memvarCreateFromDynSymbol( hb_dynsymGet( szName ), VS_PRIVATE, pItem );
hb_itemReturn( pItem );
}
hb_itemRelease( pItem );
}
hb_xfree( szName );
}
hb_fsClose( fhnd );
hb_memvarUpdatePrivatesBase();
}
else
hb_retl( FALSE );
}
else
/* NOTE: Undocumented error message in CA-Cl*pper 5.2e and 5.3x. [ckedem] */
hb_errRT_BASE( EG_ARG, 2007, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| memvars.c | 1441 |
HB_FUNC | __MVSETBASE(void)
HB_FUNC( __MVSETBASE )
{
long lOffset = hb_stackBaseProcOffset( 0 );
if( lOffset > 0 )
hb_stackItem( lOffset )->item.asSymbol.stackstate->ulPrivateBase =
hb_memvarGetPrivatesBase();
}
/* ----------------------------------------------------------------------- */
/* The garbage collector interface */
| memvars.c | 1600 |
VOID | hb_memvarsIsMemvarRef( void )
void hb_memvarsIsMemvarRef( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarsIsMemvarRef()"));
if( s_globalTable )
{
ULONG ulCnt = s_globalLastFree;
while( --ulCnt )
{
/* do not check detached variables - for these variables only
* references from the eval stack are meaningfull for the GC
*/
if( s_globalTable[ ulCnt ].counter && s_globalTable[ ulCnt ].hPrevMemvar != ( HB_HANDLE )-1 )
{
if( HB_IS_GCITEM( s_globalTable[ ulCnt ].pVarItem ) )
hb_gcItemRef( s_globalTable[ ulCnt ].pVarItem );
}
}
}
}
| memvars.c | 1621 |
HB_HANDLE | hb_memvarGetVarHandle( char *szName )
HB_HANDLE hb_memvarGetVarHandle( char *szName )
{
PHB_DYNS pDyn;
if( ( pDyn = hb_dynsymFind( szName ) ) != NULL )
return pDyn->hMemvar;
else
return 0; /* invalid handle */
}
| memvars.c | 1646 |
PHB_ITEM | hb_memvarGetValueByHandle( HB_HANDLE hMemvar )
PHB_ITEM hb_memvarGetValueByHandle( HB_HANDLE hMemvar )
{
if( hMemvar && hMemvar < s_globalTableSize )
return s_globalTable[ hMemvar ].pVarItem;
else
return NULL;
}
| memvars.c | 1656 |
memvclip.c |
Type | Function | Source | Line |
HB_FUNC | __QQPUB(void)
HB_FUNC( __QQPUB )
{
/* In Clipper __QQPUB function does not check number of parameters
or parameter type - just simply takes directly the top item from
VM stack */
if( hb_pcount() == 1 && hb_param( 1, HB_IT_STRING ) )
{
HB_FUNC_EXEC( __MVPUBLIC );
}
}
#endif
| memvclip.c | 66 |
HB_FUNC | __MCLEAR(void)
HB_FUNC( __MCLEAR )
{
HB_FUNC_EXEC( __MVCLEAR );
}
| memvclip.c | 81 |
HB_FUNC | __MRELEASE(void)
HB_FUNC( __MRELEASE )
{
HB_FUNC_EXEC( __MVRELEASE );
}
| memvclip.c | 86 |
HB_FUNC | __MXRELEASE(void)
HB_FUNC( __MXRELEASE )
{
HB_FUNC_EXEC( __MVXRELEASE );
}
| memvclip.c | 91 |
HB_FUNC | __MSAVE(void)
HB_FUNC( __MSAVE )
{
HB_FUNC_EXEC( __MVSAVE );
}
| memvclip.c | 96 |
HB_FUNC | __MRESTORE(void)
HB_FUNC( __MRESTORE )
{
HB_FUNC_EXEC( __MVRESTORE );
}
| memvclip.c | 101 |
pcount.c |
Type | Function | Source | Line |
HB_FUNC | PCOUNT(void)
HB_FUNC( PCOUNT )
{
/* Skip current function */
hb_retni( ( hb_stackItem( hb_stackBaseItem()->item.asSymbol.stackstate->lBaseItem ) )->item.asSymbol.paramcnt );
}
| pcount.c | 58 |
proc.c |
Type | Function | Source | Line |
HB_FUNC | HB_METHODNAME(void)
HB_FUNC( HB_METHODNAME )
{
char szName[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5 ];
hb_retc( hb_procname( hb_parni( 1 ) + 1, szName, TRUE ) );
}
| proc.c | 76 |
HB_FUNC | PROCNAME(void)
HB_FUNC( PROCNAME )
{
char szName[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5 ];
hb_retc( hb_procname( hb_parni( 1 ) + 1, szName, FALSE ) );
}
| proc.c | 83 |
HB_FUNC | PROCLINE(void)
HB_FUNC( PROCLINE )
{
long lOffset = hb_stackBaseProcOffset( hb_parni( 1 ) + 1 );
if( lOffset > 0 )
hb_retni( hb_stackItem( lOffset )->item.asSymbol.stackstate->uiLineNo );
else
hb_retni( 0 );
}
#ifdef HB_C52_UNDOC
| proc.c | 90 |
HB_FUNC | PROCFILE(void)
HB_FUNC( PROCFILE )
{
#ifndef HB_C52_STRICT
PHB_SYMB pSym = NULL;
if( ISSYMBOL( 1 ) )
{
pSym = hb_itemGetSymbol( hb_param( 1, HB_IT_SYMBOL ) );
}
else if( ISCHAR( 1 ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( hb_parc( 1 ) );
if( pDynSym )
pSym = pDynSym->pSymbol;
}
else
{
long lOffset = hb_stackBaseProcOffset( hb_parni( 1 ) + 1 );
if( lOffset > 0 )
{
pSym = hb_stackItem( lOffset )->item.asSymbol.value;
if( pSym == &hb_symEval || pSym->pDynSym == hb_symEval.pDynSym )
{
PHB_ITEM pSelf = hb_stackItem( lOffset + 1 );
if( HB_IS_BLOCK( pSelf ) )
pSym = pSelf->item.asBlock.value->pDefSymb;
}
}
}
hb_retc( hb_vmFindModuleSymbolName( hb_vmGetRealFuncSym( pSym ) ) );
#else
hb_retc( NULL );
#endif
}
#endif
| proc.c | 105 |
CHAR * | hb_procname( int iLevel, char * szName, BOOL fMethodName )
char * hb_procname( int iLevel, char * szName, BOOL fMethodName )
{
long lOffset = hb_stackBaseProcOffset( iLevel );
szName[ 0 ] = '\0';
if( lOffset > 0 )
{
PHB_ITEM pBase, pSelf;
pBase = hb_stackItem( lOffset );
pSelf = hb_stackItem( lOffset + 1 );
if( fMethodName && lOffset > 0 &&
pBase->item.asSymbol.value == &hb_symEval &&
pBase->item.asSymbol.stackstate->uiClass )
{
long lPrevOffset = hb_stackItem( lOffset )->item.asSymbol.stackstate->lBaseItem;
if( hb_stackItem( lPrevOffset )->item.asSymbol.stackstate->uiClass ==
pBase->item.asSymbol.stackstate->uiClass &&
hb_stackItem( lPrevOffset )->item.asSymbol.stackstate->uiMethod ==
pBase->item.asSymbol.stackstate->uiMethod )
{
pBase = hb_stackItem( lPrevOffset );
pSelf = hb_stackItem( lPrevOffset + 1 );
}
}
if( pBase->item.asSymbol.value == &hb_symEval ||
pBase->item.asSymbol.value->pDynSym == hb_symEval.pDynSym )
{
hb_strncat( szName, "(b)", HB_PROCBUF_LEN );
if( HB_IS_BLOCK( pSelf ) )
hb_strncat( szName, pSelf->item.asBlock.value->pDefSymb->szName,
HB_PROCBUF_LEN );
else
hb_strncat( szName, pBase->item.asSymbol.value->szName, HB_PROCBUF_LEN );
}
else
{
/* it is a method name? */
if( pBase->item.asSymbol.stackstate->uiClass )
{
hb_strncat( szName, hb_clsName( pBase->item.asSymbol.stackstate->uiClass ),
HB_PROCBUF_LEN );
hb_strncat( szName, ":", HB_PROCBUF_LEN );
}
hb_strncat( szName, pBase->item.asSymbol.value->szName, HB_PROCBUF_LEN );
}
}
return szName;
}
| proc.c | 150 |
BOOL | hb_procinfo( int iLevel, char * szName, USHORT * puiLine, char * szFile )
BOOL hb_procinfo( int iLevel, char * szName, USHORT * puiLine, char * szFile )
{
long lOffset = hb_stackBaseProcOffset( iLevel );
if( lOffset > 0 )
{
PHB_ITEM pBase, pSelf;
PHB_SYMB pSym;
pBase = hb_stackItem( lOffset );
pSelf = hb_stackItem( lOffset + 1 );
pSym = pBase->item.asSymbol.value;
if( szName )
{
szName[ 0 ] = '\0';
if( pSym == &hb_symEval || pSym->pDynSym == hb_symEval.pDynSym )
{
hb_strncat( szName, "(b)", HB_PROCBUF_LEN );
if( HB_IS_BLOCK( pSelf ) )
hb_strncat( szName, pSelf->item.asBlock.value->pDefSymb->szName,
HB_PROCBUF_LEN );
else
hb_strncat( szName, pSym->szName, HB_PROCBUF_LEN );
}
else
{
if( pBase->item.asSymbol.stackstate->uiClass ) /* it is a method name */
{
hb_strncat( szName, hb_clsName( pBase->item.asSymbol.stackstate->uiClass ),
HB_PROCBUF_LEN );
hb_strncat( szName, ":", HB_PROCBUF_LEN );
}
hb_strncat( szName, pSym->szName, HB_PROCBUF_LEN );
}
}
if( puiLine )
* puiLine = pBase->item.asSymbol.stackstate->uiLineNo;
if( szFile )
{
char * szModule;
if( HB_IS_BLOCK( pSelf ) &&
( pSym == &hb_symEval || pSym->pDynSym == hb_symEval.pDynSym ) )
pSym = pSelf->item.asBlock.value->pDefSymb;
szModule = hb_vmFindModuleSymbolName( hb_vmGetRealFuncSym( pSym ) );
if( szModule )
hb_strncpy( szFile, szModule, _POSIX_PATH_MAX );
else
szFile[ 0 ] = '\0';
}
return TRUE;
}
if( szName )
szName[ 0 ] = '\0';
if( puiLine )
* puiLine = 0;
if( szFile )
szFile[ 0 ] = '\0';
return FALSE;
}
| proc.c | 205 |
pvalue.c |
Type | Function | Source | Line |
HB_FUNC | HB_PVALUE(void)
HB_FUNC( HB_PVALUE )
{
LONG lOffset = hb_stackBaseItem()->item.asSymbol.stackstate->lBaseItem;
USHORT uiParam = hb_parni( 1 );
if( uiParam && uiParam <= hb_stackItem( lOffset )->item.asSymbol.paramcnt )
{
PHB_ITEM pItem = hb_stackItem( lOffset + 1 + uiParam );
if( hb_pcount() > 1 )
hb_itemCopyToRef( pItem, hb_param( 2, HB_IT_ANY ) );
hb_itemReturn( HB_IS_BYREF( pItem ) ? hb_itemUnRef( pItem ) : pItem );
}
}
| pvalue.c | 58 |
runner.c |
Type | Function | Source | Line |
STATIC INT | hb_hrbReadHead( char * szBody, ULONG ulBodySize, ULONG * pulBodyOffset )
static int hb_hrbReadHead( char * szBody, ULONG ulBodySize, ULONG * pulBodyOffset )
{
char * pVersion;
HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadHead(%p,%lu,%p)", szBody, ulBodySize, pulBodyOffset ));
if( ulBodySize < 6 || memcmp( szHead, szBody, 4 ) )
return 0;
pVersion = szBody + 4;
*pulBodyOffset += 6;
return HB_PCODE_MKSHORT( pVersion );
}
| runner.c | 103 |
STATIC BOOL | hb_hrbReadValue( char * szBody, ULONG ulBodySize, ULONG * pulBodyOffset, ULONG * pulValue )
static BOOL hb_hrbReadValue( char * szBody, ULONG ulBodySize, ULONG * pulBodyOffset, ULONG * pulValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadValue(%p,%lu,%p,%p)", szBody, ulBodySize, pulBodyOffset, pulValue));
if( *pulBodyOffset + 4 < ulBodySize )
{
*pulValue = HB_PCODE_MKLONG( szBody + *pulBodyOffset );
*pulBodyOffset += 4;
if( *pulValue <= 0x00FFFFFFUL )
{
return TRUE;
}
}
return FALSE;
}
| runner.c | 118 |
STATIC CHAR * | hb_hrbReadId( char * szBody, ULONG ulBodySize, ULONG * ulBodyOffset )
static char * hb_hrbReadId( char * szBody, ULONG ulBodySize, ULONG * ulBodyOffset )
{
char * szIdx;
HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadId(%p,%lu,%p)", szBody, ulBodySize, ulBodyOffset));
szIdx = &szBody[ *ulBodyOffset ];
do
{
if( *ulBodyOffset > ulBodySize )
return NULL;
}
while( szBody[ ( *ulBodyOffset )++ ] );
return hb_strdup( szIdx );
}
| runner.c | 136 |
STATIC ULONG | hb_hrbFindSymbol( const char * szName, PHB_DYNF pDynFunc, ULONG ulLoaded )
static ULONG hb_hrbFindSymbol( const char * szName, PHB_DYNF pDynFunc, ULONG ulLoaded )
{
ULONG ulRet;
HB_TRACE(HB_TR_DEBUG, ("hb_hrbFindSymbol(%s, %p, %lu)", szName, pDynFunc, ulLoaded));
for( ulRet = 0; ulRet < ulLoaded; ++ulRet )
{
if( ! strcmp( szName, pDynFunc[ ulRet ].szName ) )
return ulRet;
}
return SYM_NOT_FOUND;
}
| runner.c | 156 |
STATIC VOID | hb_hrbFreeSymbols( PHB_SYMB pSymbols, ULONG ulSymbols )
static void hb_hrbFreeSymbols( PHB_SYMB pSymbols, ULONG ulSymbols )
{
ULONG ul;
for( ul = 0; ul < ulSymbols; ul++ )
{
if( pSymbols[ ul ].szName )
hb_xfree( ( void * ) pSymbols[ ul ].szName );
}
hb_xfree( pSymbols );
}
| runner.c | 171 |
STATIC VOID | hb_hrbInitStatic( PHRB_BODY pHrbBody )
static void hb_hrbInitStatic( PHRB_BODY pHrbBody )
{
if( ! pHrbBody->fInit && ! pHrbBody->fExit )
{
ULONG ul;
pHrbBody->fInit = TRUE;
/* Initialize static variables first */
for( ul = 0; ul < pHrbBody->ulSymbols; ul++ ) /* Check _INITSTATICS functions */
{
if( ( pHrbBody->pSymRead[ ul ].scope.value & HB_FS_INITEXIT ) == HB_FS_INITEXIT )
{
/* call (_INITSTATICS) function. This function assigns
* literal values to static variables only. There is no need
* to pass any parameters to this function because they
* cannot be used to initialize static variable.
*/
/* changed to call VM execution instead of direct function address call
* pHrbBody->pSymRead[ ul ].value.pFunPtr();
* [MLombardo]
*/
hb_vmPushSymbol( &(pHrbBody->pSymRead[ ul ]) );
hb_vmPushNil();
hb_vmDo( 0 );
}
}
}
}
| runner.c | 183 |
STATIC VOID | hb_hrbInit( PHRB_BODY pHrbBody, int iPCount, PHB_ITEM * pParams )
static void hb_hrbInit( PHRB_BODY pHrbBody, int iPCount, PHB_ITEM * pParams )
{
if( pHrbBody->fInit )
{
if( hb_vmRequestReenter() )
{
ULONG ul;
int i;
pHrbBody->fInit = FALSE;
pHrbBody->fExit = TRUE;
for( ul = 0; ul < pHrbBody->ulSymbols; ul++ ) /* Check INIT functions */
{
if( ( pHrbBody->pSymRead[ ul ].scope.value & HB_FS_INITEXIT ) == HB_FS_INIT )
{
hb_vmPushSymbol( pHrbBody->pSymRead + ul );
hb_vmPushNil();
for( i = 0; i < iPCount; i++ )
hb_vmPush( pParams[ i ] );
hb_vmDo( iPCount );
if( hb_vmRequestQuery() != 0 )
break;
}
}
hb_vmRequestRestore();
}
}
}
| runner.c | 215 |
STATIC VOID | hb_hrbExit( PHRB_BODY pHrbBody )
static void hb_hrbExit( PHRB_BODY pHrbBody )
{
if( pHrbBody->fExit )
{
if( hb_vmRequestReenter() )
{
ULONG ul;
pHrbBody->fExit = FALSE;
pHrbBody->fInit = TRUE;
for( ul = 0; ul < pHrbBody->ulSymbols; ul++ )
{
if( ( pHrbBody->pSymRead[ ul ].scope.value & HB_FS_INITEXIT ) == HB_FS_EXIT )
{
hb_vmPushSymbol( pHrbBody->pSymRead + ul );
hb_vmPushNil();
hb_vmDo( 0 );
if( hb_vmRequestQuery() != 0 )
break;
}
}
hb_vmRequestRestore();
}
}
}
| runner.c | 246 |
STATIC VOID | hb_hrbUnLoad( PHRB_BODY pHrbBody )
static void hb_hrbUnLoad( PHRB_BODY pHrbBody )
{
ULONG ul;
hb_hrbExit( pHrbBody );
if( pHrbBody->pModuleSymbols )
{
hb_vmFreeSymbols( pHrbBody->pModuleSymbols );
}
if( pHrbBody->pDynFunc )
{
for( ul = 0; ul < pHrbBody->ulFuncs; ul++ )
{
PHB_DYNS pDyn;
if( pHrbBody->pDynFunc[ ul ].szName &&
pHrbBody->pDynFunc[ ul ].pCodeFunc )
{
pDyn = hb_dynsymFind( pHrbBody->pDynFunc[ ul ].szName );
if( pDyn && pDyn->pSymbol->value.pCodeFunc ==
pHrbBody->pDynFunc[ ul ].pCodeFunc )
{
pDyn->pSymbol->value.pCodeFunc = NULL;
}
}
if( pHrbBody->pDynFunc[ ul ].pCodeFunc )
hb_xfree( pHrbBody->pDynFunc[ ul ].pCodeFunc );
if( pHrbBody->pDynFunc[ ul ].pCode )
hb_xfree( pHrbBody->pDynFunc[ ul ].pCode );
if( pHrbBody->pDynFunc[ ul ].szName )
hb_xfree( pHrbBody->pDynFunc[ ul ].szName );
}
hb_xfree( pHrbBody->pDynFunc );
}
hb_xfree( pHrbBody );
}
| runner.c | 274 |
STATIC PHRB_BODY | hb_hrbLoad( char* szHrbBody, ULONG ulBodySize )
static PHRB_BODY hb_hrbLoad( char* szHrbBody, ULONG ulBodySize )
{
PHRB_BODY pHrbBody = NULL;
if( szHrbBody )
{
ULONG ulBodyOffset = 0;
ULONG ulSize; /* Size of function */
ULONG ul, ulPos;
PHB_SYMB pSymRead; /* Symbols read */
PHB_DYNF pDynFunc; /* Functions read */
PHB_DYNS pDynSym;
int iVersion = hb_hrbReadHead( szHrbBody, ulBodySize, &ulBodyOffset );
if( iVersion == 0 )
{
hb_errRT_BASE( EG_CORRUPTION, 9995, NULL, HB_ERR_FUNCNAME, 0 );
return NULL;
}
pHrbBody = ( PHRB_BODY ) hb_xgrab( sizeof( HRB_BODY ) );
pHrbBody->fInit = FALSE;
pHrbBody->fExit = FALSE;
pHrbBody->lSymStart = -1;
pHrbBody->ulFuncs = 0;
pHrbBody->pSymRead = NULL;
pHrbBody->pDynFunc = NULL;
pHrbBody->pModuleSymbols = NULL;
if( ! hb_hrbReadValue( szHrbBody, ulBodySize, &ulBodyOffset, &pHrbBody->ulSymbols ) ||
pHrbBody->ulSymbols == 0 )
{
hb_hrbUnLoad( pHrbBody );
hb_errRT_BASE( EG_CORRUPTION, 9996, NULL, HB_ERR_FUNCNAME, 0 );
return NULL;
}
pSymRead = ( PHB_SYMB ) hb_xgrab( pHrbBody->ulSymbols * sizeof( HB_SYMB ) );
for( ul = 0; ul < pHrbBody->ulSymbols; ul++ ) /* Read symbols in .hrb */
{
pSymRead[ ul ].szName = hb_hrbReadId( szHrbBody, ulBodySize, &ulBodyOffset );
if( pSymRead[ ul ].szName == NULL || ulBodyOffset + 2 > ulBodySize )
break;
pSymRead[ ul ].scope.value = ( BYTE ) szHrbBody[ ulBodyOffset++ ];
pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) ( HB_PTRDIFF ) szHrbBody[ ulBodyOffset++ ];
pSymRead[ ul ].pDynSym = NULL;
if( pHrbBody->lSymStart == -1 &&
( pSymRead[ ul ].scope.value & HB_FS_FIRST ) != 0 &&
( pSymRead[ ul ].scope.value & HB_FS_INITEXIT ) == 0 )
{
pHrbBody->lSymStart = ul;
}
}
if( ul < pHrbBody->ulSymbols ||
/* Read number of functions */
! hb_hrbReadValue( szHrbBody, ulBodySize, &ulBodyOffset, &pHrbBody->ulFuncs ) )
{
hb_hrbFreeSymbols( pSymRead, ul );
hb_hrbUnLoad( pHrbBody );
hb_errRT_BASE( EG_CORRUPTION, 9997, NULL, HB_ERR_FUNCNAME, 0 );
return NULL;
}
pHrbBody->pSymRead = pSymRead;
if( pHrbBody->ulFuncs )
{
pDynFunc = ( PHB_DYNF ) hb_xgrab( pHrbBody->ulFuncs * sizeof( HB_DYNF ) );
memset( pDynFunc, 0, pHrbBody->ulFuncs * sizeof( HB_DYNF ) );
pHrbBody->pDynFunc = pDynFunc;
for( ul = 0; ul < pHrbBody->ulFuncs; ul++ )
{
/* Read name of function */
pDynFunc[ ul ].szName = hb_hrbReadId( szHrbBody, ulBodySize, &ulBodyOffset );
if( pDynFunc[ ul ].szName == NULL )
break;
/* Read size of function */
if( ! hb_hrbReadValue( szHrbBody, ulBodySize, &ulBodyOffset, &ulSize ) ||
ulBodyOffset + ulSize > ulBodySize )
break;
/* Copy function body */
pDynFunc[ ul ].pCode = ( BYTE * ) hb_xgrab( ulSize );
memcpy( ( char * ) pDynFunc[ ul ].pCode, szHrbBody + ulBodyOffset, ulSize );
ulBodyOffset += ulSize;
pDynFunc[ ul ].pCodeFunc = (PHB_PCODEFUNC) hb_xgrab( sizeof( HB_PCODEFUNC ) );
pDynFunc[ ul ].pCodeFunc->pCode = pDynFunc[ ul ].pCode;
pDynFunc[ ul ].pCodeFunc->pSymbols = pSymRead;
}
if( ul < pHrbBody->ulFuncs )
{
hb_hrbFreeSymbols( pSymRead, pHrbBody->ulSymbols );
hb_hrbUnLoad( pHrbBody );
hb_errRT_BASE( EG_CORRUPTION, 9998, NULL, HB_ERR_FUNCNAME, 0 );
return NULL;
}
}
/* End of PCODE loading, now linking */
for( ul = 0; ul < pHrbBody->ulSymbols; ul++ )
{
if( pSymRead[ ul ].value.pCodeFunc == ( PHB_PCODEFUNC ) SYM_FUNC )
{
ulPos = hb_hrbFindSymbol( pSymRead[ ul ].szName, pHrbBody->pDynFunc, pHrbBody->ulFuncs );
if( ulPos == SYM_NOT_FOUND )
{
pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) SYM_EXTERN;
}
else
{
pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) pHrbBody->pDynFunc[ ulPos ].pCodeFunc;
pSymRead[ ul ].scope.value |= HB_FS_PCODEFUNC | HB_FS_LOCAL;
}
}
else if( pSymRead[ ul ].value.pCodeFunc == ( PHB_PCODEFUNC ) SYM_DEFERRED )
{
pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) SYM_EXTERN;
pSymRead[ ul ].scope.value |= HB_FS_DEFERRED;
}
/* External function */
if( pSymRead[ ul ].value.pCodeFunc == ( PHB_PCODEFUNC ) SYM_EXTERN )
{
pDynSym = hb_dynsymFind( pSymRead[ ul ].szName );
if( pDynSym )
{
pSymRead[ ul ].value.pFunPtr = pDynSym->pSymbol->value.pFunPtr;
if( pDynSym->pSymbol->scope.value & HB_FS_PCODEFUNC )
{
pSymRead[ ul ].scope.value |= HB_FS_PCODEFUNC;
}
}
else if( ( pSymRead[ ul ].scope.value & HB_FS_DEFERRED ) == 0 )
{
char szName[ HB_SYMBOL_NAME_LEN + 1 ];
hb_strncpy( szName, pSymRead[ ul ].szName, HB_SYMBOL_NAME_LEN );
hb_hrbFreeSymbols( pSymRead, pHrbBody->ulSymbols );
hb_hrbUnLoad( pHrbBody );
hb_errRT_BASE( EG_ARG, 6101, "Unknown or unregistered symbol", szName, 0 );
return NULL;
}
}
}
pHrbBody->pModuleSymbols = hb_vmRegisterSymbols( pHrbBody->pSymRead,
( USHORT ) pHrbBody->ulSymbols, "pcode.hrb", 0, TRUE, FALSE );
if( pHrbBody->pModuleSymbols->pModuleSymbols != pSymRead )
{
/*
* Old unused symbol table has been recycled - free the one
* we allocated and disactivate static initialization [druzus]
*/
pHrbBody->pSymRead = pHrbBody->pModuleSymbols->pModuleSymbols;
hb_hrbFreeSymbols( pSymRead, pHrbBody->ulSymbols );
pHrbBody->fInit = TRUE;
}
else
{
/* mark symbol table as dynamically allocated so HVM will free it on exit */
pHrbBody->pModuleSymbols->fAllocated = TRUE;
/* initialize static variables */
hb_hrbInitStatic( pHrbBody );
}
}
return pHrbBody;
}
| runner.c | 315 |
STATIC PHRB_BODY | hb_hrbLoadFromFile( char* szHrb )
static PHRB_BODY hb_hrbLoadFromFile( char* szHrb )
{
char szFileName[ _POSIX_PATH_MAX + 1 ];
PHRB_BODY pHrbBody = NULL;
PHB_FNAME pFileName;
FHANDLE hFile;
/* Create full filename */
pFileName = hb_fsFNameSplit( szHrb );
if( hb_set.HB_SET_DEFEXTENSIONS && pFileName->szExtension == NULL )
{
pFileName->szExtension = ".hrb";
}
hb_fsFNameMerge( szFileName, pFileName );
hb_xfree( pFileName );
/* Open as binary */
do
{
hFile = hb_fsOpen( ( BYTE * ) szFileName, FO_READ );
}
while( hFile == FS_ERROR &&
hb_errRT_BASE_Ext1( EG_OPEN, 6102, NULL, szFileName, hb_fsError(),
EF_CANDEFAULT | EF_CANRETRY,
HB_ERR_ARGS_BASEPARAMS ) == E_RETRY );
if( hFile != FS_ERROR )
{
ULONG ulBodySize = hb_fsSeek( hFile, 0, FS_END );
if( ulBodySize )
{
BYTE * pbyBuffer;
pbyBuffer = ( BYTE * ) hb_xgrab( ulBodySize + sizeof( char ) + 1 );
hb_fsSeek( hFile, 0, FS_SET );
hb_fsReadLarge( hFile, pbyBuffer, ulBodySize );
pbyBuffer[ ulBodySize ] = '\0';
pHrbBody = hb_hrbLoad( ( char * ) pbyBuffer, ( ULONG ) ulBodySize );
hb_xfree( pbyBuffer );
}
hb_fsClose( hFile );
}
return pHrbBody;
}
| runner.c | 499 |
STATIC VOID | hb_hrbDo( PHRB_BODY pHrbBody, int iPCount, PHB_ITEM * pParams )
static void hb_hrbDo( PHRB_BODY pHrbBody, int iPCount, PHB_ITEM * pParams )
{
PHB_ITEM pRetVal = NULL;
int i;
hb_hrbInit( pHrbBody, iPCount, pParams );
/* May not have a startup symbol, if first symbol was an INIT Symbol (was executed already).*/
if( pHrbBody->lSymStart >= 0 && hb_vmRequestQuery() == 0 )
{
hb_vmPushSymbol( &pHrbBody->pSymRead[ pHrbBody->lSymStart ] );
hb_vmPushNil();
for( i = 0; i < ( hb_pcount() - 1 ); i++ )
{
hb_vmPush( hb_param( i + 2, HB_IT_ANY ) ); /* Push other cmdline params*/
}
hb_vmDo( hb_pcount() - 1 ); /* Run the thing !!! */
pRetVal = hb_itemNew( NULL );
hb_itemMove( pRetVal, hb_stackReturnItem() );
}
hb_hrbExit( pHrbBody );
if( pRetVal )
{
hb_itemReturnRelease( pRetVal );
}
}
| runner.c | 549 |
STATIC HB_GARBAGE_FUNC( | hb_hrb_Destructor )
static HB_GARBAGE_FUNC( hb_hrb_Destructor )
{
PHRB_BODY * pHrbPtr = ( PHRB_BODY * ) Cargo;
if( *pHrbPtr )
{
hb_hrbUnLoad( *pHrbPtr );
*pHrbPtr = NULL;
}
}
| runner.c | 581 |
STATIC PHRB_BODY | hb_hrbParam( int iParam )
static PHRB_BODY hb_hrbParam( int iParam )
{
PHRB_BODY * pHrbPtr = ( PHRB_BODY * ) hb_parptrGC( hb_hrb_Destructor, iParam );
return pHrbPtr ? *pHrbPtr : NULL;
}
| runner.c | 593 |
STATIC VOID | hb_hrbReturn( PHRB_BODY pHrbBody )
static void hb_hrbReturn( PHRB_BODY pHrbBody )
{
PHRB_BODY * pHrbPtr = ( PHRB_BODY * ) hb_gcAlloc( sizeof( PHRB_BODY ),
hb_hrb_Destructor );
*pHrbPtr = pHrbBody;
hb_retptrGC( pHrbPtr );
}
/*
__HRBRUN( [, xParam1 [, xParamN ] ] ) -> return value.
This program will get the data from the .hrb file and run the p-code
contained in it.
| runner.c | 600 |
HB_FUNC | __HRBRUN(void)
In due time it should also be able to collect the data from the
binary/executable itself
*/
HB_FUNC( __HRBRUN )
{
ULONG ulLen = hb_parclen( 1 );
if( ulLen > 0 )
{
char * fileOrBody = hb_parc( 1 );
PHRB_BODY pHrbBody;
if( ulLen > 4 && memcmp( szHead, fileOrBody, 4 ) == 0 )
pHrbBody = hb_hrbLoad( fileOrBody, ulLen );
else
pHrbBody = hb_hrbLoadFromFile( fileOrBody );
if( pHrbBody )
{
int iPCount = hb_pcount() - 1, i;
PHB_ITEM * pParams = NULL;
if( iPCount > 0 )
{
pParams = ( PHB_ITEM * ) hb_xgrab( sizeof( PHB_ITEM ) * iPCount );
for( i = 0; i < iPCount; i++ )
pParams[ i ] = hb_param( i + 2, HB_IT_ANY );
}
hb_hrbDo( pHrbBody, iPCount, pParams );
if( pParams )
hb_xfree( pParams );
hb_hrbUnLoad( pHrbBody );
hb_retl( TRUE );
}
else
hb_retl( FALSE );
}
else
hb_errRT_BASE( EG_ARG, 6103, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| runner.c | 614 |
HB_FUNC | __HRBLOAD(void)
HB_FUNC( __HRBLOAD )
{
ULONG ulLen = hb_parclen( 1 );
if( ulLen > 0 )
{
char * fileOrBody = hb_parc( 1 );
PHRB_BODY pHrbBody;
if( ulLen > 4 && memcmp( szHead, fileOrBody, 4 ) == 0 )
pHrbBody = hb_hrbLoad( fileOrBody, ulLen );
else
pHrbBody = hb_hrbLoadFromFile( fileOrBody );
if( pHrbBody )
{
int iPCount = hb_pcount() - 1;
PHB_ITEM * pParams = NULL;
int i;
if( iPCount > 0 )
{
pParams = ( PHB_ITEM * ) hb_xgrab( sizeof( PHB_ITEM ) * iPCount );
for( i = 0; i < iPCount; i++ )
pParams[ i ] = hb_param( i + 2, HB_IT_ANY );
}
hb_hrbInit( pHrbBody, iPCount, pParams );
if( pParams )
hb_xfree( pParams );
}
hb_hrbReturn( pHrbBody );
}
else
hb_errRT_BASE( EG_ARG, 9998, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| runner.c | 658 |
HB_FUNC | __HRBDO(void)
HB_FUNC( __HRBDO )
{
PHRB_BODY pHrbBody = hb_hrbParam( 1 );
if( pHrbBody )
{
int iPCount = hb_pcount() - 1;
PHB_ITEM * pParams = NULL;
int i;
if( iPCount > 0 )
{
pParams = ( PHB_ITEM * ) hb_xgrab( sizeof( PHB_ITEM ) * iPCount );
for( i = 0; i < iPCount; i++ )
pParams[ i ] = hb_param( i + 2, HB_IT_ANY );
}
hb_hrbDo( pHrbBody, iPCount, pParams );
if( pParams )
hb_xfree( pParams );
}
else
hb_errRT_BASE( EG_ARG, 6104, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| runner.c | 697 |
HB_FUNC | __HRBUNLOAD(void)
HB_FUNC( __HRBUNLOAD )
{
PHRB_BODY * pHrbPtr = ( PHRB_BODY * ) hb_parptrGC( hb_hrb_Destructor, 1 );
if( pHrbPtr )
{
PHRB_BODY pHrbBody = *pHrbPtr;
if( pHrbBody )
{
*pHrbPtr = NULL;
hb_hrbUnLoad( pHrbBody );
}
}
else
hb_errRT_BASE( EG_ARG, 6105, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| runner.c | 724 |
HB_FUNC | __HRBGETFU(void)
HB_FUNC( __HRBGETFU )
{
PHRB_BODY pHrbBody = hb_hrbParam( 1 );
if( pHrbBody && hb_parclen( 2 ) > 0 )
{
char * szName = hb_strupr( hb_strdup( hb_parc( 2 ) ) );
ULONG ulPos = 0;
while( ulPos < pHrbBody->ulSymbols )
{
if( !strcmp( szName, pHrbBody->pSymRead[ ulPos ].szName ) )
break;
ulPos++;
}
hb_xfree( szName );
if( ulPos < pHrbBody->ulSymbols )
hb_itemPutSymbol( hb_stackReturnItem(), pHrbBody->pSymRead + ulPos );
}
else
hb_errRT_BASE( EG_ARG, 6106, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| runner.c | 742 |
HB_FUNC | __HRBDOFU(void)
HB_FUNC( __HRBDOFU )
{
PHB_ITEM pSymItem = hb_param( 1, HB_IT_SYMBOL );
if( pSymItem )
{
int iPCount = hb_pcount() - 1;
int i;
hb_vmPushSymbol( hb_itemGetSymbol( pSymItem ) );
hb_vmPushNil();
for( i = 0; i < iPCount; i++ )
hb_vmPush( hb_stackItemFromBase( i + 2 ) );
hb_vmDo( iPCount );
}
else
hb_errRT_BASE( EG_ARG, 6107, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
}
| runner.c | 766 |
vm.c |
Type | Function | Source | Line |
HB_EXPORT HB_VMHANDLE | hb_xvalloc( ULONG nSize, USHORT nFlags )
HB_EXPORT HB_VMHANDLE hb_xvalloc( ULONG nSize, USHORT nFlags )
{
/* TODO */
HB_SYMBOL_UNUSED( nSize );
HB_SYMBOL_UNUSED( nFlags );
return 0;
}
| vm.c | 60 |
HB_EXPORT VOID | hb_xvfree( HB_VMHANDLE h )
HB_EXPORT void hb_xvfree( HB_VMHANDLE h )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
}
| vm.c | 68 |
HB_EXPORT HB_VMHANDLE | hb_xvrealloc( HB_VMHANDLE h, ULONG nSize, USHORT nFlags )
HB_EXPORT HB_VMHANDLE hb_xvrealloc( HB_VMHANDLE h, ULONG nSize, USHORT nFlags )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
HB_SYMBOL_UNUSED( nSize );
HB_SYMBOL_UNUSED( nFlags );
return 0;
}
| vm.c | 74 |
HB_EXPORT VOID * | hb_xvlock( HB_VMHANDLE h )
HB_EXPORT void * hb_xvlock( HB_VMHANDLE h )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
return NULL;
}
| vm.c | 83 |
HB_EXPORT VOID | hb_xvunlock( HB_VMHANDLE h )
HB_EXPORT void hb_xvunlock( HB_VMHANDLE h )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
}
| vm.c | 90 |
HB_EXPORT VOID * | hb_xvwire( HB_VMHANDLE h )
HB_EXPORT void * hb_xvwire( HB_VMHANDLE h )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
return NULL;
}
| vm.c | 98 |
HB_EXPORT VOID | hb_xvunwire( HB_VMHANDLE h )
HB_EXPORT void hb_xvunwire( HB_VMHANDLE h )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
}
| vm.c | 105 |
HB_EXPORT ULONG | hb_xvlockcount( HB_VMHANDLE h )
HB_EXPORT ULONG hb_xvlockcount( HB_VMHANDLE h )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
return 0;
}
| vm.c | 114 |
HB_EXPORT ULONG | hb_xvsize( HB_VMHANDLE h )
HB_EXPORT ULONG hb_xvsize( HB_VMHANDLE h )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
return 0;
}
| vm.c | 121 |
HB_EXPORT HB_VMHANDLE | hb_xvheapnew( ULONG nSize )
HB_EXPORT HB_VMHANDLE hb_xvheapnew( ULONG nSize )
{
/* TODO */
HB_SYMBOL_UNUSED( nSize );
return 0;
}
| vm.c | 130 |
HB_EXPORT VOID | hb_xvheapdestroy( HB_VMHANDLE h )
HB_EXPORT void hb_xvheapdestroy( HB_VMHANDLE h )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
}
| vm.c | 137 |
HB_EXPORT HB_VMHANDLE | hb_xvheapresize( HB_VMHANDLE h, ULONG nSize )
HB_EXPORT HB_VMHANDLE hb_xvheapresize( HB_VMHANDLE h, ULONG nSize )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
HB_SYMBOL_UNUSED( nSize );
return 0;
}
| vm.c | 143 |
HB_EXPORT ULONG | hb_xvheapalloc( HB_VMHANDLE h, ULONG nSize )
HB_EXPORT ULONG hb_xvheapalloc( HB_VMHANDLE h, ULONG nSize )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
HB_SYMBOL_UNUSED( nSize );
return 0;
}
| vm.c | 151 |
HB_EXPORT VOID | hb_xvheapfree( HB_VMHANDLE h, ULONG nOffset )
HB_EXPORT void hb_xvheapfree( HB_VMHANDLE h, ULONG nOffset )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
HB_SYMBOL_UNUSED( nOffset );
}
| vm.c | 159 |
HB_EXPORT VOID * | hb_xvheaplock( HB_VMHANDLE h, ULONG nOffset )
HB_EXPORT void * hb_xvheaplock( HB_VMHANDLE h, ULONG nOffset )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
HB_SYMBOL_UNUSED( nOffset );
return NULL;
}
| vm.c | 166 |
HB_EXPORT VOID | hb_xvheapunlock( HB_VMHANDLE h, ULONG nOffset )
HB_EXPORT void hb_xvheapunlock( HB_VMHANDLE h, ULONG nOffset )
{
/* TODO */
HB_SYMBOL_UNUSED( h );
HB_SYMBOL_UNUSED( nOffset );
}
| vm.c | 174 |
harbinit.prg |
Type | Function | Source | Line |
PROCEDURE | CLIPPER520()
PROCEDURE CLIPPER520()
RETURN
#ifdef HB_COMPAT_C53
| harbinit.prg | 58 |
PROCEDURE | CLIPPER530()
PROCEDURE CLIPPER530()
RETURN
#endif
| harbinit.prg | 64 |
PROCEDURE | ClipInit
PROCEDURE ClipInit
MEMVAR GetList
PUBLIC GetList := {}
ErrorSys()
/* TOFIX: In Clipper this function is not called from here CLIPINIT(). */
/* NOTE: In Clipper __SETHELPK() is called *after* ERRORSYS(). */
IF Type( "HELP()" ) == "UI"
__SetHelpK()
ENDIF
RETURN
| harbinit.prg | 75 |
PROCEDURE | __SetHelpK()
PROCEDURE __SetHelpK()
SET KEY K_F1 TO __XHELP
RETURN
| harbinit.prg | 91 |
|