From 29f11ab65c809946f052abb9de014d2d8f094fc9 Mon Sep 17 00:00:00 2001 From: Przemyslaw Czerpak Date: Sat, 25 Mar 2006 02:44:01 +0000 Subject: [PATCH] 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. + added DBI_LOCKOFFSET * harbour/source/vm/classes.c * formatting * harbour/source/vm/hvm.c * harbour/source/vm/itemapi.c * some minor speed optimizations --- harbour/ChangeLog | 27 +++++++++ harbour/include/hbapi.h | 95 ++++++++++++++++++++++++++++--- harbour/include/hbstack.h | 17 +++--- harbour/source/compiler/genc.c | 2 +- harbour/source/compiler/hbpcode.c | 4 +- harbour/source/rdd/dbf1.c | 2 + harbour/source/vm/classes.c | 6 +- harbour/source/vm/estack.c | 50 +++++----------- harbour/source/vm/hvm.c | 22 +++---- harbour/source/vm/itemapi.c | 38 ++++++++----- 10 files changed, 175 insertions(+), 88 deletions(-) diff --git a/harbour/ChangeLog b/harbour/ChangeLog index 924a06952d..f1253355c9 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -8,6 +8,33 @@ 2002-12-01 13:30 UTC+0100 Foo Bar */ * 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. diff --git a/harbour/include/hbapi.h b/harbour/include/hbapi.h index 38852e9d47..0c46e82b4c 100644 --- a/harbour/include/hbapi.h +++ b/harbour/include/hbapi.h @@ -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 */ diff --git a/harbour/include/hbstack.h b/harbour/include/hbstack.h index 000591d869..25d721d6db 100644 --- a/harbour/include/hbstack.h +++ b/harbour/include/hbstack.h @@ -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 ); diff --git a/harbour/source/compiler/genc.c b/harbour/source/compiler/genc.c index 2284cfb705..67d8f4149f 100644 --- a/harbour/source/compiler/genc.c +++ b/harbour/source/compiler/genc.c @@ -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 ] = '_'; } diff --git a/harbour/source/compiler/hbpcode.c b/harbour/source/compiler/hbpcode.c index 0f140d3eeb..baedc8e30b 100644 --- a/harbour/source/compiler/hbpcode.c +++ b/harbour/source/compiler/hbpcode.c @@ -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 ) diff --git a/harbour/source/rdd/dbf1.c b/harbour/source/rdd/dbf1.c index 75ab54bac7..04195084c5 100644 --- a/harbour/source/rdd/dbf1.c +++ b/harbour/source/rdd/dbf1.c @@ -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 ); diff --git a/harbour/source/vm/classes.c b/harbour/source/vm/classes.c index 262aabfc30..e21a7258b8 100644 --- a/harbour/source/vm/classes.c +++ b/harbour/source/vm/classes.c @@ -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 ); } diff --git a/harbour/source/vm/estack.c b/harbour/source/vm/estack.c index 8443b56d7a..dc46d61dc5 100644 --- a/harbour/source/vm/estack.c +++ b/harbour/source/vm/estack.c @@ -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 ) diff --git a/harbour/source/vm/hvm.c b/harbour/source/vm/hvm.c index 5de7d96fa4..203717ea40 100644 --- a/harbour/source/vm/hvm.c +++ b/harbour/source/vm/hvm.c @@ -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 { diff --git a/harbour/source/vm/itemapi.c b/harbour/source/vm/itemapi.c index ec5bfc167f..1df33181f1 100644 --- a/harbour/source/vm/itemapi.c +++ b/harbour/source/vm/itemapi.c @@ -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 )