fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2006-03-25 03:30 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl)

Browse Source 
* harbour/include/hbstack.h
  * harbour/source/vm/estack.c
    * added pEnd to hb_stack structure to speed up hb_stackPush()
      which is one of the most often used operation in HVM.

  * harbour/include/hbapi.h
    * small trick with HB_IS_* macros to give a compiler a chance to make
      them faster on some machines

  * harbour/source/compiler/genc.c
    ! fixed stripping non identifier characters from symbol table name

  * harbour/source/compiler/hbpcode.c
    * cleaned comment

  * harbour/source/rdd/dbf1.c
    * set Operation in error object to field name in field{put,get} methods.
    + added DBI_LOCKOFFSET

  * harbour/source/vm/classes.c
    * formatting

  * harbour/source/vm/hvm.c
  * harbour/source/vm/itemapi.c
    * some minor speed optimizations
This commit is contained in:
Przemyslaw Czerpak
2006-03-25 02:44:01 +00:00
parent 7ed7c4709d
commit 29f11ab65c
10 changed files with 175 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
harbour/ChangeLog
View File

@@ -8,6 +8,33 @@
2002-12-01 13:30 UTC+0100 Foo Bar <foo.bar@foobar.org>
*/
* source/pp/ppcore.c
* contrib/htmllib/default.ch
* source/compiler/hbident.c
* source/compiler/harbour.l
* source/pp/ppcore.c
* fixed my last commits
* processed this file with indent
2006-03-25 03:30 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
* harbour/include/hbstack.h
* harbour/source/vm/estack.c
* added pEnd to hb_stack structure to speed up hb_stackPush()
which is one of the most often used operation in HVM.
* harbour/include/hbapi.h
* small trick with HB_IS_* macros to give a compiler a chance to make
them faster on some machines
* harbour/source/compiler/genc.c
! fixed stripping non identifier characters from symbol table name
* harbour/source/compiler/hbpcode.c
* cleaned comment
* harbour/source/rdd/dbf1.c
* set Operation in error object to field name in field{put,get} methods.

95
harbour/include/hbapi.h
View File

@@ -97,29 +97,107 @@ HB_EXTERN_BEGIN
#define HB_IT_COMPLEX ( ( HB_TYPE ) ( HB_IT_STRING | HB_IT_BLOCK | HB_IT_ARRAY | HB_IT_MEMVAR | HB_IT_BYREF ) )
#define HB_IT_GCITEM ( ( HB_TYPE ) ( HB_IT_BLOCK | HB_IT_ARRAY | HB_IT_POINTER | HB_IT_BYREF ) )
#if 0
/*
* In Harbour VM HB_IT_BYREF is never ORed with item type. It can be used
* as stand alone type for locals and statics passed by reference or with
* HB_IT_MEMVAR for memvars passed by reference so this macro is less usable.
* only the hb_parinfo() function can return HB_TYPE as HB_IT_BYREF ORed
* with real type but this value is never set as item type.
*/
#define HB_IS_OF_TYPE( p, t ) ( ( HB_ITEM_TYPE( p ) & ~HB_IT_BYREF ) == t )
#define HB_IS_BYREF( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_BYREF ) != 0 )
#define HB_IS_ARRAY( p ) HB_IS_OF_TYPE( p, HB_IT_ARRAY )
/*
* These macros are slower but can be usable in debugging some code.
* They are a little bit more safe in buggy code but they can
* also hide bugs which should be exploited as soon as possible to
* know that sth is wrong and has to be fixed.
* the version below which check only chosen bits allow compiler to
* use some optimizations if used CPU supports it. F.e. on standard
* x86 machines they can safe few CPU cycles. [druzus]
*/
#define HB_IS_NIL( p ) HB_IS_OF_TYPE( p, HB_IT_NIL )
#define HB_IS_ARRAY( p ) HB_IS_OF_TYPE( p, HB_IT_ARRAY )
#define HB_IS_BLOCK( p ) HB_IS_OF_TYPE( p, HB_IT_BLOCK )
#define HB_IS_DATE( p ) HB_IS_OF_TYPE( p, HB_IT_DATE )
#define HB_IS_DOUBLE( p ) HB_IS_OF_TYPE( p, HB_IT_DOUBLE )
#define HB_IS_INTEGER( p ) HB_IS_OF_TYPE( p, HB_IT_INTEGER )
#define HB_IS_LOGICAL( p ) HB_IS_OF_TYPE( p, HB_IT_LOGICAL )
#define HB_IS_LONG( p ) HB_IS_OF_TYPE( p, HB_IT_LONG )
#define HB_IS_OBJECT( p ) ( HB_IS_OF_TYPE( p, HB_IT_OBJECT ) && HB_OBJ_CLASS( p ) != 0 )
#define HB_IS_STRING( p ) ( ( HB_ITEM_TYPE( p ) & ~( HB_IT_BYREF | HB_IT_MEMOFLAG ) ) == HB_IT_STRING )
#define HB_IS_MEMO( p ) HB_IS_OF_TYPE( p, HB_IT_MEMO )
#define HB_IS_SYMBOL( p ) HB_IS_OF_TYPE( p, HB_IT_SYMBOL )
#define HB_IS_MEMVAR( p ) HB_IS_OF_TYPE( p, HB_IT_MEMVAR )
#define HB_IS_POINTER( p ) HB_IS_OF_TYPE( p, HB_IT_POINTER )
#define HB_IS_MEMVAR( p ) HB_IS_OF_TYPE( p, HB_IT_MEMVAR )
#define HB_IS_MEMO( p ) HB_IS_OF_TYPE( p, HB_IT_MEMO )
#define HB_IS_STRING( p ) ( ( HB_ITEM_TYPE( p ) & ~( HB_IT_BYREF | HB_IT_MEMOFLAG ) ) == HB_IT_STRING )
#define HB_IS_BYREF( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_BYREF ) != 0 )
#define HB_IS_NUMERIC( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMERIC ) != 0 )
#define HB_IS_NUMBER( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMERIC ) != 0 )
#define HB_IS_NUMINT( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMINT ) != 0 )
#define HB_IS_COMPLEX( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 )
#define HB_IS_GCITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_GCITEM ) != 0 )
#define HB_IS_BADITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX != 0 ) && ( HB_ITEM_TYPE( p ) & ~( HB_IT_COMPLEX | HB_IT_MEMOFLAG ) ) != 0 )
#define HB_IS_BADITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 && ( HB_ITEM_TYPE( p ) & ~( HB_IT_COMPLEX | HB_IT_MEMOFLAG ) ) != 0 )
#define HB_IS_OBJECT( p ) ( HB_IS_ARRAY( p ) && HB_OBJ_CLASS( p ) != 0 )
#define HB_IS_NUMBER( p ) HB_IS_NUMERIC( p )
#elif 0
/*
* these macros illustrates possible HB_TYPE bit combinations in HVM,
* they are the safest one in buggy code which may produce wrong item
* signatures but also they can be slower on some machines
*/
#define HB_IS_NIL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_NIL )
#define HB_IS_ARRAY( p ) ( HB_ITEM_TYPE( p ) == HB_IT_ARRAY )
#define HB_IS_BLOCK( p ) ( HB_ITEM_TYPE( p ) == HB_IT_BLOCK )
#define HB_IS_DATE( p ) ( HB_ITEM_TYPE( p ) == HB_IT_DATE )
#define HB_IS_DOUBLE( p ) ( HB_ITEM_TYPE( p ) == HB_IT_DOUBLE )
#define HB_IS_INTEGER( p ) ( HB_ITEM_TYPE( p ) == HB_IT_INTEGER )
#define HB_IS_LOGICAL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_LOGICAL )
#define HB_IS_LONG( p ) ( HB_ITEM_TYPE( p ) == HB_IT_LONG )
#define HB_IS_SYMBOL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_SYMBOL )
#define HB_IS_POINTER( p ) ( HB_ITEM_TYPE( p ) == HB_IT_POINTER )
#define HB_IS_MEMO( p ) ( HB_ITEM_TYPE( p ) == HB_IT_MEMO )
#define HB_IS_MEMVAR( p ) ( HB_ITEM_TYPE( p ) == ( HB_IT_MEMVAR | HB_IT_BYREF ) )
#define HB_IS_STRING( p ) ( ( HB_ITEM_TYPE( p ) & ~HB_IT_MEMOFLAG ) == HB_IT_STRING )
#define HB_IS_BYREF( p ) ( ( HB_ITEM_TYPE( p ) & ~HB_IT_MEMVAR ) == HB_IT_BYREF )
#define HB_IS_NUMERIC( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMERIC ) != 0 )
#define HB_IS_NUMINT( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMINT ) != 0 )
#define HB_IS_COMPLEX( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 )
#define HB_IS_GCITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_GCITEM ) != 0 )
#define HB_IS_BADITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 && ( HB_ITEM_TYPE( p ) & ~( HB_IT_COMPLEX | HB_IT_MEMOFLAG ) ) != 0 )
#define HB_IS_OBJECT( p ) ( HB_IS_ARRAY( p ) && HB_OBJ_CLASS( p ) != 0 )
#define HB_IS_NUMBER( p ) HB_IS_NUMERIC( p )
#else
/*
* these ones are can be the most efficiently optimized on some CPUs
*/
#define HB_IS_NIL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_NIL )
#define HB_IS_ARRAY( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_ARRAY ) != 0 )
#define HB_IS_BLOCK( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_BLOCK ) != 0 )
#define HB_IS_DATE( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_DATE ) != 0 )
#define HB_IS_DOUBLE( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_DOUBLE ) != 0 )
#define HB_IS_INTEGER( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_INTEGER ) != 0 )
#define HB_IS_LOGICAL( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_LOGICAL ) != 0 )
#define HB_IS_LONG( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_LONG ) != 0 )
#define HB_IS_SYMBOL( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_SYMBOL ) != 0 )
#define HB_IS_POINTER( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_POINTER ) != 0 )
#define HB_IS_MEMO( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_MEMOFLAG ) != 0 )
#define HB_IS_STRING( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_STRING ) != 0 )
#define HB_IS_MEMVAR( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_MEMVAR ) != 0 )
#define HB_IS_BYREF( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_BYREF ) != 0 )
#define HB_IS_NUMERIC( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMERIC ) != 0 )
#define HB_IS_NUMINT( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMINT ) != 0 )
#define HB_IS_COMPLEX( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 )
#define HB_IS_GCITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_GCITEM ) != 0 )
#define HB_IS_BADITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 && ( HB_ITEM_TYPE( p ) & ~( HB_IT_COMPLEX | HB_IT_MEMOFLAG ) ) != 0 )
#define HB_IS_OBJECT( p ) ( HB_IS_ARRAY( p ) && HB_OBJ_CLASS( p ) != 0 )
#define HB_IS_NUMBER( p ) HB_IS_NUMERIC( p )
#endif
#define ISNIL( n ) ( hb_param( n, HB_IT_ANY ) == NULL || HB_IS_NIL( hb_param( n, HB_IT_ANY ) ) ) /* NOTE: Intentionally using a different method */
@@ -135,7 +213,6 @@ HB_EXTERN_BEGIN
#define ISPOINTER( n ) ( hb_param( n, HB_IT_POINTER ) != NULL ) /* Not available in CA-Cl*pper. */
#ifdef _HB_API_INTERNAL_
/* forward declarations */

17
harbour/include/hbstack.h
View File

@@ -69,12 +69,13 @@ typedef struct
{
PHB_ITEM * pItems; /* pointer to the stack items */
PHB_ITEM * pPos; /* pointer to the latest used item */
LONG wItems; /* total items that may be holded on the stack */
HB_ITEM Return; /* latest returned value */
PHB_ITEM * pEnd; /* pointer to the end of stack items */
LONG wItems; /* total items that may be holded on the stack */
HB_ITEM Return; /* latest returned value */
PHB_ITEM * pBase; /* stack frame position for the current function call */
PHB_ITEM * pEvalBase; /* stack frame position for the evaluated codeblock */
int iStatics; /* statics base for the current function call */
char szDate[ 9 ]; /* last returned date from _pards() yyyymmdd format */
int iStatics; /* statics base for the current function call */
char szDate[ 9 ]; /* last returned date from _pards() yyyymmdd format */
} HB_STACK;
extern HB_STACK hb_stack;
@@ -116,15 +117,11 @@ typedef struct
if( HB_IS_COMPLEX( * hb_stack.pPos ) ) \
hb_itemClear( * hb_stack.pPos ); \
} while ( 0 )
#define hb_stackPush( ) do { \
if( hb_stack.wItems - 1 <= hb_stack.pPos - hb_stack.pItems ) \
{ \
if( ++hb_stack.pPos == hb_stack.pEnd ) \
hb_stackIncrease(); \
} \
( * (++hb_stack.pPos) )->type = HB_IT_NIL; \
( * hb_stack.pPos )->type = HB_IT_NIL; \
} while ( 0 )
#else
extern HB_ITEM_PTR hb_stackItemFromTop( int nFromTop );

2
harbour/source/compiler/genc.c
View File

@@ -161,7 +161,7 @@ void hb_compGenCCode( PHB_FNAME pFileName ) /* generates the C language ou
if ( ! ( c >= 'A' && c <= 'Z' ) &&
! ( c >= 'a' && c <= 'z' ) &&
! ( c >= '0' && c <= '9' ) &&
! c == '_' )
! ( c == '_' ) )
{
szModulname[ i ] = '_';
}

4
harbour/source/compiler/hbpcode.c
View File

@@ -222,8 +222,8 @@ void hb_compPCodeEval( PFUNCTION pFunc, HB_PCODE_FUNC_PTR * pFunctions, void * c
}
#if 0
/*
* Test code to validate return values by PCODE eavl functions,
* in some cases the eval functions can return intentinally differ
* Test code to validate return values by PCODE eval functions,
* in some cases the eval functions can return intentionally differ
* values so it's not enabled by default. [druzus]
*/
if( hb_comp_pcode_len[ opcode ] != 0 && hb_comp_pcode_len[ opcode ] != ulSkip )

2
harbour/source/rdd/dbf1.c
View File

@@ -1457,6 +1457,7 @@ static ERRCODE hb_dbfGetValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
pError = hb_errNew();
hb_errPutGenCode( pError, EG_DATATYPE );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_DATATYPE ) );
hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) );
hb_errPutSubCode( pError, EDBF_DATATYPE );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
@@ -1816,6 +1817,7 @@ static ERRCODE hb_dbfPutValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
pError = hb_errNew();
hb_errPutGenCode( pError, hb_dbfGetEGcode( uiError ) );
hb_errPutDescription( pError, hb_langDGetErrorDesc( hb_dbfGetEGcode( uiError ) ) );
hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) );
hb_errPutSubCode( pError, uiError );
hb_errPutFlags( pError, EF_CANDEFAULT );
SELF_ERROR( ( AREAP ) pArea, pError );

6
harbour/source/vm/classes.c
View File

@@ -2146,10 +2146,10 @@ static HARBOUR hb___msgClsParent( void )
if( HB_IS_OBJECT( pItemParam ) )
szParentName = hb_objGetClsName( pItemParam );
else if( HB_IS_STRING( pItemParam ) )
{
{
szParentName = hb_itemGetC( pItemParam );
lClass=TRUE;
}
}
for( i = 0; szParentName[ i ] != '\0'; i++ )
szParentName[ i ] = ( char ) toupper( szParentName[ i ] );
@@ -2157,7 +2157,7 @@ static HARBOUR hb___msgClsParent( void )
hb_retl( hb_clsIsParent( uiClass , szParentName ) );
if (lClass)
hb_itemFreeC( szParentName );
hb_itemFreeC( szParentName );
}

50
harbour/source/vm/estack.c
View File

@@ -121,38 +121,13 @@ void hb_stackFree( void )
#undef hb_stackPush
void hb_stackPush( void )
{
LONG CurrIndex; /* index of current top item */
LONG TopIndex; /* index of the topmost possible item */
HB_TRACE(HB_TR_DEBUG, ("hb_stackPush()"));
CurrIndex = hb_stack.pPos - hb_stack.pItems;
TopIndex = hb_stack.wItems - 1;
/* enough room for another item ? */
if( !( TopIndex > CurrIndex ) )
{
LONG BaseIndex; /* index of stack base */
LONG i;
BaseIndex = hb_stack.pBase - hb_stack.pItems;
/* no, make more headroom: */
/* hb_stackDispLocal(); */
hb_stack.pItems = ( HB_ITEM_PTR * ) hb_xrealloc( ( void *)hb_stack.pItems, sizeof( HB_ITEM_PTR ) *
( 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;
for( i=CurrIndex + 1; i < hb_stack.wItems; ++i )
hb_stack.pItems[ i ] = (HB_ITEM *) hb_xgrab( sizeof( HB_ITEM ) );
/* hb_stackDispLocal(); */
}
if( ++hb_stack.pPos == hb_stack.pEnd )
hb_stackIncrease();
/* now, push it: */
hb_stack.pPos++;
( * hb_stack.pPos )->type = HB_IT_NIL;
}
@@ -160,24 +135,26 @@ void hb_stackIncrease( void )
{
LONG BaseIndex; /* index of stack base */
LONG CurrIndex; /* index of current top item */
LONG i;
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_stackDispLocal(); */
hb_stack.pItems = ( HB_ITEM_PTR * ) hb_xrealloc( ( void *)hb_stack.pItems, sizeof( HB_ITEM_PTR ) *
( hb_stack.wItems + STACK_EXPANDHB_ITEMS ) );
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.pPos = hb_stack.pItems + CurrIndex;
hb_stack.pBase = hb_stack.pItems + BaseIndex;
hb_stack.wItems += STACK_EXPANDHB_ITEMS;
for( i = CurrIndex + 1; i < hb_stack.wItems; ++i )
hb_stack.pItems[ i ] = (HB_ITEM *) hb_xgrab( sizeof( HB_ITEM ) );
hb_stack.pEnd = hb_stack.pItems + hb_stack.wItems;
while( EndIndex < hb_stack.wItems )
hb_stack.pItems[ EndIndex++ ] = ( PHB_ITEM ) hb_xgrab( sizeof( HB_ITEM ) );
}
void hb_stackInit( void )
@@ -186,13 +163,14 @@ void hb_stackInit( void )
HB_TRACE(HB_TR_DEBUG, ("hb_stackInit()"));
hb_stack.pItems = ( HB_ITEM_PTR * ) hb_xgrab( sizeof( HB_ITEM_PTR ) * STACK_INITHB_ITEMS );
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 ] = (HB_ITEM *) hb_xgrab( sizeof( HB_ITEM ) );
hb_stack.pItems[ i ] = ( PHB_ITEM ) hb_xgrab( sizeof( HB_ITEM ) );
}
void hb_stackRemove( LONG lUntilPos )

22
harbour/source/vm/hvm.c
View File

@@ -3579,7 +3579,7 @@ static void hb_vmArrayPush( void )
/* this is a temporary copy of an array - we can overwrite
* it with no problem
*/
hb_arrayGet( pArray, ulIndex, pArray );
hb_itemCopy( pArray, pArray->item.asArray.value->pItems + ulIndex - 1 );
hb_stackPop();
}
else
@@ -3587,7 +3587,7 @@ static void hb_vmArrayPush( void )
/* this is a constant array { 1, 2, 3 } - we cannot use
* the optimization here
*/
hb_arrayGet( pArray, ulIndex, pIndex );
hb_itemMove( pIndex, pArray->item.asArray.value->pItems + ulIndex - 1 );
hb_itemMove( pArray, pIndex );
hb_stackDec();
}
@@ -3654,12 +3654,10 @@ static void hb_vmArrayPop( void )
if( ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
pValue->type &= ~HB_IT_MEMOFLAG;
hb_arraySet( pArray, ulIndex, pValue );
/* This is no longer needed as we manage the array by reference */
/* hb_itemCopy( pArray, pValue ); places pValue at pArray position */
hb_itemMove( pArray->item.asArray.value->pItems + ulIndex - 1, pValue );
hb_stackPop();
hb_stackPop();
hb_stackPop(); /* remove the value from the stack just like other POP operations */
hb_stackDec(); /* value was moved above hb_stackDec() is enough */
}
else
hb_errRT_BASE( EG_BOUND, 1133, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 1, pIndex );
@@ -4647,7 +4645,7 @@ static void hb_vmRetValue( void )
static void hb_vmDebuggerEndProc( void )
{
PHB_ITEM pReturn
PHB_ITEM pReturn;
HB_TRACE(HB_TR_DEBUG, ("hb_vmDebuggerEndProc()"));
@@ -6841,7 +6839,7 @@ static void hb_vmArrayItemPush( ULONG ulIndex )
/* this is a temporary copy of an array - we can overwrite
* it with no problem
*/
hb_arrayGet( pArray, ulIndex, pArray );
hb_itemCopy( pArray, pArray->item.asArray.value->pItems + ulIndex - 1 );
}
else
{
@@ -6851,7 +6849,7 @@ static void hb_vmArrayItemPush( ULONG ulIndex )
PHB_ITEM pItem = hb_stackTopItem();
hb_stackPush();
hb_arrayGet( pArray, ulIndex, pItem );
hb_itemMove( pItem, pArray->item.asArray.value->pItems + ulIndex - 1 );
hb_itemMove( pArray, pItem );
hb_stackDec();
}
@@ -6911,11 +6909,9 @@ static void hb_vmArrayItemPop( ULONG ulIndex )
if( ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
pValue->type &= ~HB_IT_MEMOFLAG;
hb_arraySet( pArray, ulIndex, pValue );
/* This is no longer needed as we manage the array by reference */
/* hb_itemCopy( pArray, pValue ); places pValue at pArray position */
hb_itemMove( pArray->item.asArray.value->pItems + ulIndex - 1, pValue );
hb_stackPop();
hb_stackPop(); /* remove the value from the stack just like other POP operations */
hb_stackDec(); /* value was moved above hb_stackDec() is enough */
}
else
{

38
harbour/source/vm/itemapi.c
View File

@@ -1059,7 +1059,15 @@ HB_EXPORT PHB_ITEM hb_itemPutNumType( PHB_ITEM pItem, double dNumber, int iDec,
}
else if ( HB_DBL_LIM_INT( dNumber ) )
{
return hb_itemPutNInt( pItem, ( HB_LONG ) 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
{
@@ -1196,9 +1204,7 @@ HB_EXPORT void hb_itemClear( PHB_ITEM pItem )
if( HB_IS_STRING( pItem ) )
{
if( pItem->item.asString.bStatic )
pItem->item.asString.value = NULL;
else
if( !pItem->item.asString.bStatic )
{
if( --*( pItem->item.asString.u.pulHolders ) == 0 )
{
@@ -1207,12 +1213,14 @@ HB_EXPORT void hb_itemClear( PHB_ITEM pItem )
hb_xfree( pItem->item.asString.u.pulHolders );
}
}
pItem->item.asString.length = 0;
}
else if( HB_IS_ARRAY( pItem ) && pItem->item.asArray.value )
else if( HB_IS_ARRAY( pItem ) )
{
if( --( pItem->item.asArray.value )->ulHolders == 0 )
hb_arrayRelease( pItem );
if( pItem->item.asArray.value )
{
if( --( pItem->item.asArray.value )->ulHolders == 0 )
hb_arrayRelease( pItem );
}
}
else if( HB_IS_BLOCK( pItem ) )
hb_codeblockDelete( pItem );
@@ -1220,12 +1228,15 @@ HB_EXPORT void hb_itemClear( PHB_ITEM pItem )
else if( HB_IS_MEMVAR( pItem ) )
hb_memvarValueDecRef( pItem->item.asMemvar.value );
else if( HB_IS_BYREF( pItem ) && pItem->item.asRefer.offset < 0 && pItem->item.asRefer.value >= 0 )
else if( HB_IS_BYREF( pItem ) )
{
/* FOR EACH control variable */
hb_itemRelease( pItem->item.asRefer.BasePtr.itemPtr );
if( pItem->item.asRefer.ValuePtr.itemPtr )
hb_itemRelease( pItem->item.asRefer.ValuePtr.itemPtr );
if( pItem->item.asRefer.offset < 0 && pItem->item.asRefer.value >= 0 )
{
/* FOR EACH control variable */
hb_itemRelease( pItem->item.asRefer.BasePtr.itemPtr );
if( pItem->item.asRefer.ValuePtr.itemPtr )
hb_itemRelease( pItem->item.asRefer.ValuePtr.itemPtr );
}
}
#if defined( HB_FM_STATISTICS ) && defined( HB_PARANOID_MEM_CHECK )
@@ -1991,7 +2002,6 @@ HB_EXPORT char * hb_itemPadConv( PHB_ITEM pItem, ULONG * pulSize, BOOL * bFreeRe
{
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_itemPadConv(%p, %p, %p)", pItem, pulSize, bFreeReq));
/* to be clipper compatible don't convert HB_IT_BYREF items */
if( pItem )
{
switch( pItem->type )