From fa8024e0246cd086c59682b977e8d2b747469f2d Mon Sep 17 00:00:00 2001 From: Viktor Szakats Date: Tue, 6 Jul 2010 19:45:23 +0000 Subject: [PATCH] 2010-07-06 21:44 UTC+0200 Viktor Szakats (harbour.01 syenar.hu) * src/vm/hashfunc.c * src/vm/macro.c * src/vm/estack.c * src/vm/codebloc.c * src/vm/hashes.c * src/vm/debug.c * src/vm/asort.c * src/vm/garbage.c * src/vm/hvm.c * src/vm/cmdarg.c * src/vm/arrays.c * src/vm/fm.c * src/vm/arrayshb.c * src/vm/extend.c * src/vm/classes.c * Renamed HB_SIZE variables to have 'n' prefix. (verified to generate the same objects as before) ; TOFIX: as marked in hvm.c. --- harbour/ChangeLog | 20 ++ harbour/src/vm/arrays.c | 396 +++++++++++++++--------------- harbour/src/vm/arrayshb.c | 106 ++++----- harbour/src/vm/asort.c | 48 ++-- harbour/src/vm/classes.c | 192 +++++++-------- harbour/src/vm/cmdarg.c | 24 +- harbour/src/vm/codebloc.c | 20 +- harbour/src/vm/debug.c | 36 +-- harbour/src/vm/estack.c | 18 +- harbour/src/vm/extend.c | 180 +++++++------- harbour/src/vm/fm.c | 246 +++++++++---------- harbour/src/vm/garbage.c | 10 +- harbour/src/vm/hashes.c | 490 +++++++++++++++++++------------------- harbour/src/vm/hashfunc.c | 128 +++++----- harbour/src/vm/hvm.c | 348 +++++++++++++-------------- harbour/src/vm/macro.c | 202 ++++++++-------- 16 files changed, 1242 insertions(+), 1222 deletions(-) diff --git a/harbour/ChangeLog b/harbour/ChangeLog index e0a3dad108..d11b3cf6cf 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -16,6 +16,26 @@ The license applies to all entries newer than 2009-04-28. */ +2010-07-06 21:44 UTC+0200 Viktor Szakats (harbour.01 syenar.hu) + * src/vm/hashfunc.c + * src/vm/macro.c + * src/vm/estack.c + * src/vm/codebloc.c + * src/vm/hashes.c + * src/vm/debug.c + * src/vm/asort.c + * src/vm/garbage.c + * src/vm/hvm.c + * src/vm/cmdarg.c + * src/vm/arrays.c + * src/vm/fm.c + * src/vm/arrayshb.c + * src/vm/extend.c + * src/vm/classes.c + * Renamed HB_SIZE variables to have 'n' prefix. + (verified to generate the same objects as before) + ; TOFIX: as marked in hvm.c. + 2010-07-06 21:00 UTC+0200 Viktor Szakats (harbour.01 syenar.hu) * utils/hbrun/hbrun.prg ! Don't search passed program in PATH and hbrun dir, if diff --git a/harbour/src/vm/arrays.c b/harbour/src/vm/arrays.c index 7154dd7ae3..1d15471150 100644 --- a/harbour/src/vm/arrays.c +++ b/harbour/src/vm/arrays.c @@ -82,7 +82,7 @@ static void hb_arrayReleaseItems( PHB_BASEARRAY pBaseArray ) if( pBaseArray->nLen ) { HB_ITEM_PTR pItems = pBaseArray->pItems; - HB_SIZE ulLen = pBaseArray->nLen; + HB_SIZE nLen = pBaseArray->nLen; /* * clear the pBaseArray->pItems to avoid infinite loop in cross @@ -92,10 +92,10 @@ static void hb_arrayReleaseItems( PHB_BASEARRAY pBaseArray ) pBaseArray->pItems = NULL; pBaseArray->nLen = 0; - while( ulLen-- ) + while( nLen-- ) { - if( HB_IS_COMPLEX( pItems + ulLen ) ) - hb_itemClear( pItems + ulLen ); + if( HB_IS_COMPLEX( pItems + nLen ) ) + hb_itemClear( pItems + nLen ); } hb_xfree( pItems ); } @@ -161,13 +161,13 @@ static HB_GARBAGE_FUNC( hb_arrayGarbageMark ) if( pBaseArray->nLen ) { - HB_SIZE ulLen = pBaseArray->nLen; + HB_SIZE nLen = pBaseArray->nLen; HB_ITEM_PTR pItems = pBaseArray->pItems; - while( ulLen-- ) + while( nLen-- ) { - if( HB_IS_GCITEM( pItems + ulLen ) ) - hb_gcItemRef( pItems + ulLen ); + if( HB_IS_GCITEM( pItems + nLen ) ) + hb_gcItemRef( pItems + nLen ); } } } @@ -179,13 +179,13 @@ static const HB_GC_FUNCS s_gcArrayFuncs = }; -HB_BOOL hb_arrayNew( PHB_ITEM pItem, HB_SIZE ulLen ) /* creates a new array */ +HB_BOOL hb_arrayNew( PHB_ITEM pItem, HB_SIZE nLen ) /* creates a new array */ { PHB_BASEARRAY pBaseArray; PHB_ITEM pItems; - HB_SIZE ulPos; + HB_SIZE nPos; - HB_TRACE(HB_TR_DEBUG, ("hb_arrayNew(%p, %" HB_PFS "u)", pItem, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayNew(%p, %" HB_PFS "u)", pItem, nLen)); if( HB_IS_COMPLEX( pItem ) ) hb_itemClear( pItem ); @@ -195,52 +195,52 @@ HB_BOOL hb_arrayNew( PHB_ITEM pItem, HB_SIZE ulLen ) /* creates a new array */ * safe for automatic GC activation in hb_xgrab() without * calling hb_gcLock()/hb_gcUnlock(). [druzus] */ - if( ulLen > 0 ) + if( nLen > 0 ) { - pItems = ( PHB_ITEM ) hb_xgrab( sizeof( HB_ITEM ) * ulLen ); - for( ulPos = 0; ulPos < ulLen; ++ulPos ) - ( pItems + ulPos )->type = HB_IT_NIL; + pItems = ( PHB_ITEM ) hb_xgrab( sizeof( HB_ITEM ) * nLen ); + for( nPos = 0; nPos < nLen; ++nPos ) + ( pItems + nPos )->type = HB_IT_NIL; } else pItems = NULL; pBaseArray = ( PHB_BASEARRAY ) hb_gcAllocRaw( sizeof( HB_BASEARRAY ), &s_gcArrayFuncs ); pBaseArray->pItems = pItems; - pBaseArray->nLen = ulLen; + pBaseArray->nLen = nLen; pBaseArray->uiClass = 0; pBaseArray->uiPrevCls = 0; - pBaseArray->nAllocated = ulLen; + pBaseArray->nAllocated = nLen; pItem->type = HB_IT_ARRAY; pItem->item.asArray.value = pBaseArray; return HB_TRUE; } -HB_BOOL hb_arraySize( PHB_ITEM pArray, HB_SIZE ulLen ) +HB_BOOL hb_arraySize( PHB_ITEM pArray, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySize(%p, %" HB_PFS "u)", pArray, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySize(%p, %" HB_PFS "u)", pArray, nLen)); if( HB_IS_ARRAY( pArray ) ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - if( ulLen != pBaseArray->nLen ) + if( nLen != pBaseArray->nLen ) { - HB_SIZE ulPos; + HB_SIZE nPos; if( pBaseArray->nLen == 0 ) { - pBaseArray->pItems = ( PHB_ITEM ) hb_xgrab( ulLen * sizeof( HB_ITEM ) ); - pBaseArray->nAllocated = ulLen; + pBaseArray->pItems = ( PHB_ITEM ) hb_xgrab( nLen * sizeof( HB_ITEM ) ); + pBaseArray->nAllocated = nLen; - for( ulPos = 0; ulPos < ulLen; ulPos++ ) - ( pBaseArray->pItems + ulPos )->type = HB_IT_NIL; + for( nPos = 0; nPos < nLen; nPos++ ) + ( pBaseArray->pItems + nPos )->type = HB_IT_NIL; } else { - if( pBaseArray->nLen < ulLen ) + if( pBaseArray->nLen < nLen ) { - if( pBaseArray->nAllocated < ulLen ) + if( pBaseArray->nAllocated < nLen ) { /* A common practice is to double allocation buffer size. Thus, making @@ -253,37 +253,37 @@ HB_BOOL hb_arraySize( PHB_ITEM pArray, HB_SIZE ulLen ) size is not doubled, but multiplied by 1.5; - adding of 1, allows reduce reallocation count for small arrays. */ - pBaseArray->nAllocated = ( pBaseArray->nAllocated >> 1 ) + 1 + ulLen; + pBaseArray->nAllocated = ( pBaseArray->nAllocated >> 1 ) + 1 + nLen; pBaseArray->pItems = ( PHB_ITEM ) hb_xrealloc( pBaseArray->pItems, sizeof( HB_ITEM ) * pBaseArray->nAllocated ); } /* set value for new items */ - for( ulPos = pBaseArray->nLen; ulPos < ulLen; ulPos++ ) - ( pBaseArray->pItems + ulPos )->type = HB_IT_NIL; + for( nPos = pBaseArray->nLen; nPos < nLen; nPos++ ) + ( pBaseArray->pItems + nPos )->type = HB_IT_NIL; } - else if( pBaseArray->nLen > ulLen ) + else if( pBaseArray->nLen > nLen ) { /* release old items */ - for( ulPos = ulLen; ulPos < pBaseArray->nLen; ulPos++ ) + for( nPos = nLen; nPos < pBaseArray->nLen; nPos++ ) { - if( HB_IS_COMPLEX( pBaseArray->pItems + ulPos ) ) - hb_itemClear( pBaseArray->pItems + ulPos ); + if( HB_IS_COMPLEX( pBaseArray->pItems + nPos ) ) + hb_itemClear( pBaseArray->pItems + nPos ); } - if( ulLen == 0 ) + if( nLen == 0 ) { hb_xfree( pBaseArray->pItems ); pBaseArray->pItems = NULL; } - else if( ulLen < ( pBaseArray->nAllocated >> 1 ) ) + else if( nLen < ( pBaseArray->nAllocated >> 1 ) ) { - pBaseArray->pItems = ( PHB_ITEM ) hb_xrealloc( pBaseArray->pItems, sizeof( HB_ITEM ) * ulLen ); - pBaseArray->nAllocated = ulLen; + pBaseArray->pItems = ( PHB_ITEM ) hb_xrealloc( pBaseArray->pItems, sizeof( HB_ITEM ) * nLen ); + pBaseArray->nAllocated = nLen; } } } - pBaseArray->nLen = ulLen; + pBaseArray->nLen = nLen; } return HB_TRUE; @@ -369,19 +369,19 @@ HB_BOOL hb_arrayDel( PHB_ITEM pArray, HB_SIZE nIndex ) if( HB_IS_ARRAY( pArray ) ) { - HB_SIZE ulLen = pArray->item.asArray.value->nLen; + HB_SIZE nLen = pArray->item.asArray.value->nLen; - if( nIndex > 0 && nIndex <= ulLen ) + if( nIndex > 0 && nIndex <= nLen ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - if( nIndex == ulLen ) + if( nIndex == nLen ) { hb_itemSetNil( pBaseArray->pItems + nIndex - 1 ); } else { - for( ; nIndex < ulLen; ++nIndex ) /* move items */ + for( ; nIndex < nLen; ++nIndex ) /* move items */ hb_itemMoveRef( pBaseArray->pItems + nIndex - 1, pBaseArray->pItems + nIndex ); } @@ -399,21 +399,21 @@ HB_BOOL hb_arrayIns( PHB_ITEM pArray, HB_SIZE nIndex ) if( HB_IS_ARRAY( pArray ) ) { - HB_SIZE ulLen = pArray->item.asArray.value->nLen; + HB_SIZE nLen = pArray->item.asArray.value->nLen; - if( nIndex > 0 && nIndex <= ulLen ) + if( nIndex > 0 && nIndex <= nLen ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - if( nIndex == ulLen ) + if( nIndex == nLen ) { hb_itemSetNil( pBaseArray->pItems + nIndex - 1 ); } else { - while( --ulLen >= nIndex ) /* move items */ - hb_itemMoveRef( pBaseArray->pItems + ulLen, - pBaseArray->pItems + ulLen - 1 ); + while( --nLen >= nIndex ) /* move items */ + hb_itemMoveRef( pBaseArray->pItems + nLen, + pBaseArray->pItems + nLen - 1 ); } return HB_TRUE; @@ -626,12 +626,12 @@ double hb_arrayGetND( PHB_ITEM pArray, HB_SIZE nIndex ) return 0; } -HB_SIZE hb_arrayCopyC( PHB_ITEM pArray, HB_SIZE nIndex, char * szBuffer, HB_SIZE ulLen ) +HB_SIZE hb_arrayCopyC( PHB_ITEM pArray, HB_SIZE nIndex, char * szBuffer, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopyC(%p, %" HB_PFS "u, %s, %" HB_PFS "u)", pArray, nIndex, szBuffer, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopyC(%p, %" HB_PFS "u, %s, %" HB_PFS "u)", pArray, nIndex, szBuffer, nLen)); if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) - return hb_itemCopyC( pArray->item.asArray.value->pItems + nIndex - 1, szBuffer, ulLen ); + return hb_itemCopyC( pArray->item.asArray.value->pItems + nIndex - 1, szBuffer, nLen ); else return 0; } @@ -865,26 +865,26 @@ HB_BOOL hb_arraySetC( PHB_ITEM pArray, HB_SIZE nIndex, const char * szText ) return HB_FALSE; } -HB_BOOL hb_arraySetCL( PHB_ITEM pArray, HB_SIZE nIndex, const char * szText, HB_SIZE ulLen ) +HB_BOOL hb_arraySetCL( PHB_ITEM pArray, HB_SIZE nIndex, const char * szText, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, nIndex, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, nIndex, szText, nLen)); if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutCL( pArray->item.asArray.value->pItems + nIndex - 1, szText, ulLen ); + hb_itemPutCL( pArray->item.asArray.value->pItems + nIndex - 1, szText, nLen ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetCLPtr( PHB_ITEM pArray, HB_SIZE nIndex, char * szText, HB_SIZE ulLen ) +HB_BOOL hb_arraySetCLPtr( PHB_ITEM pArray, HB_SIZE nIndex, char * szText, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetCLPtr(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, nIndex, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetCLPtr(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, nIndex, szText, nLen)); if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutCLPtr( pArray->item.asArray.value->pItems + nIndex - 1, szText, ulLen ); + hb_itemPutCLPtr( pArray->item.asArray.value->pItems + nIndex - 1, szText, nLen ); return HB_TRUE; } else @@ -957,28 +957,28 @@ HB_BOOL hb_arrayFill( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SI if( HB_IS_ARRAY( pArray ) ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - HB_SIZE ulLen = pBaseArray->nLen; - HB_SIZE ulStart; - HB_SIZE ulCount; + HB_SIZE nLen = pBaseArray->nLen; + HB_SIZE nStart; + HB_SIZE nCount; if( pnStart && *pnStart ) - ulStart = *pnStart - 1; + nStart = *pnStart - 1; else - ulStart = 0; + nStart = 0; - if( ulStart < ulLen ) + if( nStart < nLen ) { - ulCount = ulLen - ulStart; - if( pnCount && *pnCount < ulCount ) - ulCount = *pnCount; + nCount = nLen - nStart; + if( pnCount && *pnCount < nCount ) + nCount = *pnCount; - if( ulCount > 0 ) + if( nCount > 0 ) { do { - hb_itemCopy( pBaseArray->pItems + ulStart++, pValue ); + hb_itemCopy( pBaseArray->pItems + nStart++, pValue ); } - while( --ulCount > 0 ); + while( --nCount > 0 ); } } @@ -995,22 +995,22 @@ HB_SIZE hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SI if( HB_IS_ARRAY( pArray ) ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - HB_SIZE ulLen = pBaseArray->nLen; - HB_SIZE ulStart; - HB_SIZE ulCount; + HB_SIZE nLen = pBaseArray->nLen; + HB_SIZE nStart; + HB_SIZE nCount; if( pnStart && *pnStart ) - ulStart = *pnStart - 1; + nStart = *pnStart - 1; else - ulStart = 0; + nStart = 0; - if( ulStart < ulLen ) + if( nStart < nLen ) { - ulCount = ulLen - ulStart; - if( pnCount && *pnCount < ulCount ) - ulCount = *pnCount; + nCount = nLen - nStart; + if( pnCount && *pnCount < nCount ) + nCount = *pnCount; - if( ulCount > 0 ) + if( nCount > 0 ) { /* Make separate search loops for different types to find, so that the loop can be faster. */ @@ -1022,27 +1022,27 @@ HB_SIZE hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SI { hb_vmPushEvalSym(); hb_vmPush( pValue ); - hb_vmPush( pBaseArray->pItems + ulStart ); - hb_vmPushSize( ++ulStart ); + hb_vmPush( pBaseArray->pItems + nStart ); + hb_vmPushSize( ++nStart ); hb_vmEval( 2 ); if( HB_IS_LOGICAL( hb_stackReturnItem() ) && hb_stackReturnItem()->item.asLogical.value ) - return ulStart; + return nStart; } - while( --ulCount > 0 && ulStart < pBaseArray->nLen ); + while( --nCount > 0 && nStart < pBaseArray->nLen ); } else if( HB_IS_STRING( pValue ) ) { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart++; + PHB_ITEM pItem = pBaseArray->pItems + nStart++; /* 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; + return nStart; } - while( --ulCount > 0 ); + while( --nCount > 0 ); } else if( HB_IS_NUMERIC( pValue ) ) { @@ -1050,12 +1050,12 @@ HB_SIZE hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SI do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart++; + PHB_ITEM pItem = pBaseArray->pItems + nStart++; if( HB_IS_NUMERIC( pItem ) && hb_itemGetND( pItem ) == dValue ) - return ulStart; + return nStart; } - while( --ulCount > 0 ); + while( --nCount > 0 ); } else if( HB_IS_DATETIME( pValue ) ) { @@ -1063,26 +1063,26 @@ HB_SIZE hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SI { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart++; + PHB_ITEM pItem = pBaseArray->pItems + nStart++; if( HB_IS_DATETIME( pItem ) && pItem->item.asDateTime.julian == pValue->item.asDateTime.julian && pItem->item.asDateTime.time == pValue->item.asDateTime.time ) - return ulStart; + return nStart; } - while( --ulCount > 0 ); + while( --nCount > 0 ); } else { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart++; + PHB_ITEM pItem = pBaseArray->pItems + nStart++; if( HB_IS_DATETIME( pItem ) && pItem->item.asDateTime.julian == pValue->item.asDateTime.julian ) - return ulStart; + return nStart; } - while( --ulCount > 0 ); + while( --nCount > 0 ); } } else if( HB_IS_LOGICAL( pValue ) ) @@ -1091,59 +1091,59 @@ HB_SIZE hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SI do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart++; + PHB_ITEM pItem = pBaseArray->pItems + nStart++; if( HB_IS_LOGICAL( pItem ) && hb_itemGetL( pItem ) == bValue ) - return ulStart; + return nStart; } - while( --ulCount > 0 ); + while( --nCount > 0 ); } else if( HB_IS_NIL( pValue ) ) { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart++; + PHB_ITEM pItem = pBaseArray->pItems + nStart++; if( HB_IS_NIL( pItem ) ) - return ulStart; + return nStart; } - while( --ulCount > 0 ); + while( --nCount > 0 ); } else if( HB_IS_POINTER( pValue ) ) { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart++; + PHB_ITEM pItem = pBaseArray->pItems + nStart++; if( HB_IS_POINTER( pItem ) && pItem->item.asPointer.value == pValue->item.asPointer.value ) - return ulStart; + return nStart; } - while( --ulCount > 0 ); + while( --nCount > 0 ); } else if( fExact && HB_IS_ARRAY( pValue ) ) { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart++; + PHB_ITEM pItem = pBaseArray->pItems + nStart++; if( HB_IS_ARRAY( pItem ) && pItem->item.asArray.value == pValue->item.asArray.value ) - return ulStart; + return nStart; } - while( --ulCount > 0 ); + while( --nCount > 0 ); } else if( fExact && HB_IS_HASH( pValue ) ) { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart++; + PHB_ITEM pItem = pBaseArray->pItems + nStart++; if( HB_IS_HASH( pItem ) && pItem->item.asHash.value == pValue->item.asHash.value ) - return ulStart; + return nStart; } - while( --ulCount > 0 ); + while( --nCount > 0 ); } } } @@ -1159,22 +1159,22 @@ HB_SIZE hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB if( HB_IS_ARRAY( pArray ) ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - HB_SIZE ulLen = pBaseArray->nLen; - HB_SIZE ulStart; - HB_SIZE ulCount; + HB_SIZE nLen = pBaseArray->nLen; + HB_SIZE nStart; + HB_SIZE nCount; if( pnStart && *pnStart ) - ulStart = *pnStart - 1; + nStart = *pnStart - 1; else - ulStart = ulLen - 1; + nStart = nLen - 1; - if( ulStart < ulLen ) + if( nStart < nLen ) { - ulCount = ulStart + 1; - if( pnCount && *pnCount < ulCount ) - ulCount = *pnCount; + nCount = nStart + 1; + if( pnCount && *pnCount < nCount ) + nCount = *pnCount; - if( ulCount > 0 ) + if( nCount > 0 ) { /* Make separate search loops for different types to find, so that the loop can be faster. */ @@ -1186,30 +1186,30 @@ HB_SIZE hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB { hb_vmPushEvalSym(); hb_vmPush( pValue ); - if( ulStart < pBaseArray->nLen ) - hb_vmPush( pBaseArray->pItems + ulStart ); + if( nStart < pBaseArray->nLen ) + hb_vmPush( pBaseArray->pItems + nStart ); else hb_vmPushNil(); - hb_vmPushSize( ulStart + 1 ); + hb_vmPushSize( nStart + 1 ); hb_vmEval( 2 ); if( HB_IS_LOGICAL( hb_stackReturnItem() ) && hb_stackReturnItem()->item.asLogical.value ) - return ulStart + 1; + return nStart + 1; } - while( --ulCount && ulStart-- ); + while( --nCount && nStart-- ); } else if( HB_IS_STRING( pValue ) ) { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart; + PHB_ITEM pItem = pBaseArray->pItems + nStart; /* 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; + return nStart + 1; } - while( --ulCount && ulStart-- ); + while( --nCount && nStart-- ); } else if( HB_IS_NUMERIC( pValue ) ) { @@ -1217,12 +1217,12 @@ HB_SIZE hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart; + PHB_ITEM pItem = pBaseArray->pItems + nStart; if( HB_IS_NUMERIC( pItem ) && hb_itemGetND( pItem ) == dValue ) - return ulStart + 1; + return nStart + 1; } - while( --ulCount && ulStart-- ); + while( --nCount && nStart-- ); } else if( HB_IS_DATETIME( pValue ) ) { @@ -1230,26 +1230,26 @@ HB_SIZE hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart; + PHB_ITEM pItem = pBaseArray->pItems + nStart; if( HB_IS_DATETIME( pItem ) && pItem->item.asDateTime.julian == pValue->item.asDateTime.julian && pItem->item.asDateTime.time == pValue->item.asDateTime.time ) - return ulStart + 1; + return nStart + 1; } - while( --ulCount && ulStart-- ); + while( --nCount && nStart-- ); } else { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart; + PHB_ITEM pItem = pBaseArray->pItems + nStart; if( HB_IS_DATETIME( pItem ) && pItem->item.asDateTime.julian == pValue->item.asDateTime.julian ) - return ulStart + 1; + return nStart + 1; } - while( --ulCount && ulStart-- ); + while( --nCount && nStart-- ); } } else if( HB_IS_LOGICAL( pValue ) ) @@ -1258,59 +1258,59 @@ HB_SIZE hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart; + PHB_ITEM pItem = pBaseArray->pItems + nStart; if( HB_IS_LOGICAL( pItem ) && hb_itemGetL( pItem ) == bValue ) - return ulStart + 1; + return nStart + 1; } - while( --ulCount && ulStart-- ); + while( --nCount && nStart-- ); } else if( HB_IS_NIL( pValue ) ) { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart; + PHB_ITEM pItem = pBaseArray->pItems + nStart; if( HB_IS_NIL( pItem ) ) - return ulStart + 1; + return nStart + 1; } - while( --ulCount && ulStart-- ); + while( --nCount && nStart-- ); } else if( HB_IS_POINTER( pValue ) ) { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart; + PHB_ITEM pItem = pBaseArray->pItems + nStart; if( HB_IS_POINTER( pItem ) && pItem->item.asPointer.value == pValue->item.asPointer.value ) - return ulStart + 1; + return nStart + 1; } - while( --ulCount && ulStart-- ); + while( --nCount && nStart-- ); } else if( fExact && HB_IS_ARRAY( pValue ) ) { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart; + PHB_ITEM pItem = pBaseArray->pItems + nStart; if( HB_IS_ARRAY( pItem ) && pItem->item.asArray.value == pValue->item.asArray.value ) - return ulStart + 1; + return nStart + 1; } - while( --ulCount && ulStart-- ); + while( --nCount && nStart-- ); } else if( fExact && HB_IS_HASH( pValue ) ) { do { - PHB_ITEM pItem = pBaseArray->pItems + ulStart; + PHB_ITEM pItem = pBaseArray->pItems + nStart; if( HB_IS_HASH( pItem ) && pItem->item.asHash.value == pValue->item.asHash.value ) - return ulStart + 1; + return nStart + 1; } - while( --ulCount && ulStart-- ); + while( --nCount && nStart-- ); } } } @@ -1326,34 +1326,34 @@ HB_BOOL hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, HB_SIZE * pnStart, HB_SI if( HB_IS_ARRAY( pArray ) && HB_IS_BLOCK( bBlock ) ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - HB_SIZE ulLen = pBaseArray->nLen; - HB_SIZE ulStart; - HB_SIZE ulCount; + HB_SIZE nLen = pBaseArray->nLen; + HB_SIZE nStart; + HB_SIZE nCount; if( pnStart && *pnStart ) - ulStart = *pnStart - 1; + nStart = *pnStart - 1; else - ulStart = 0; + nStart = 0; - if( ulStart < ulLen ) + if( nStart < nLen ) { - ulCount = ulLen - ulStart; - if( pnCount && *pnCount < ulCount ) - ulCount = *pnCount; + nCount = nLen - nStart; + if( pnCount && *pnCount < nCount ) + nCount = *pnCount; - if( ulCount > 0 ) + if( nCount > 0 ) { do { hb_vmPushEvalSym(); hb_vmPush( bBlock ); - hb_vmPush( pBaseArray->pItems + ulStart ); - hb_vmPushSize( ulStart + 1 ); + hb_vmPush( pBaseArray->pItems + nStart ); + hb_vmPushSize( nStart + 1 ); hb_vmEval( 2 ); } - while( --ulCount > 0 && ++ulStart < pBaseArray->nLen ); + while( --nCount > 0 && ++nStart < pBaseArray->nLen ); /* - * checking for ulStart < pBaseArray->nLen is fix for + * checking for nStart < pBaseArray->nLen is fix for * possible GPF when codeblock decrease array size */ } @@ -1369,61 +1369,61 @@ HB_BOOL hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, HB_SIZE * pnStart, HB_SI is greater than the length of the array. [vszakats] */ HB_BOOL hb_arrayCopy( PHB_ITEM pSrcArray, PHB_ITEM pDstArray, HB_SIZE * pnStart, - HB_SIZE * pnCount, HB_SIZE * pulTarget ) + HB_SIZE * pnCount, HB_SIZE * pnTarget ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopy(%p, %p, %p, %p, %p)", pSrcArray, pDstArray, pnStart, pnCount, pulTarget)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopy(%p, %p, %p, %p, %p)", pSrcArray, pDstArray, pnStart, pnCount, pnTarget)); if( HB_IS_ARRAY( pSrcArray ) && HB_IS_ARRAY( pDstArray ) ) { PHB_BASEARRAY pSrcBaseArray = pSrcArray->item.asArray.value; PHB_BASEARRAY pDstBaseArray = pDstArray->item.asArray.value; - HB_SIZE ulSrcLen = pSrcBaseArray->nLen; - HB_SIZE ulDstLen = pDstBaseArray->nLen; - HB_SIZE ulStart; - HB_SIZE ulCount; - HB_SIZE ulTarget; + HB_SIZE nSrcLen = pSrcBaseArray->nLen; + HB_SIZE nDstLen = pDstBaseArray->nLen; + HB_SIZE nStart; + HB_SIZE nCount; + HB_SIZE nTarget; if( pnStart && ( *pnStart >= 1 ) ) - ulStart = *pnStart; + nStart = *pnStart; else - ulStart = 1; + nStart = 1; - if( pulTarget && ( *pulTarget >= 1 ) ) - ulTarget = *pulTarget; + if( pnTarget && ( *pnTarget >= 1 ) ) + nTarget = *pnTarget; else - ulTarget = 1; + nTarget = 1; #ifdef HB_COMPAT_C53 /* From CA-Cl*pper 5.3a */ - if( ulStart <= ulSrcLen ) + if( nStart <= nSrcLen ) #else - if( ulSrcLen > 0 ) + if( nSrcLen > 0 ) #endif { #ifndef HB_COMPAT_C53 /* From CA-Cl*pper 5.3a */ - if( ulStart > ulSrcLen ) - ulStart = ulSrcLen; + if( nStart > nSrcLen ) + nStart = nSrcLen; #endif - if( pnCount && ( *pnCount <= ulSrcLen - ulStart ) ) - ulCount = *pnCount; + if( pnCount && ( *pnCount <= nSrcLen - nStart ) ) + nCount = *pnCount; else - ulCount = ulSrcLen - ulStart + 1; + nCount = nSrcLen - nStart + 1; /* This is probably a bug, present in all versions of CA-Cl*pper. */ #if defined( HB_CLP_STRICT ) || 1 - if( ulDstLen > 0 ) + if( nDstLen > 0 ) { - if( ulTarget > ulDstLen ) - ulTarget = ulDstLen; + if( nTarget > nDstLen ) + nTarget = nDstLen; #else - if( ulTarget <= ulDstLen ) + if( nTarget <= nDstLen ) { #endif - if( ulCount > ulDstLen - ulTarget ) - ulCount = ulDstLen - ulTarget + 1; + if( nCount > nDstLen - nTarget ) + nCount = nDstLen - nTarget + 1; - for( ulTarget--, ulStart--; ulCount > 0; ulCount--, ulStart++, ulTarget++ ) - hb_itemCopy( pDstBaseArray->pItems + ulTarget, pSrcBaseArray->pItems + ulStart ); + for( nTarget--, nStart--; nCount > 0; nCount--, nStart++, nTarget++ ) + hb_itemCopy( pDstBaseArray->pItems + nTarget, pSrcBaseArray->pItems + nStart ); } } @@ -1436,7 +1436,7 @@ HB_BOOL hb_arrayCopy( PHB_ITEM pSrcArray, PHB_ITEM pDstArray, HB_SIZE * pnStart, static void hb_arrayCloneBody( PHB_BASEARRAY pSrcBaseArray, PHB_BASEARRAY pDstBaseArray, PHB_NESTED_CLONED pClonedList ) { PHB_ITEM pSrcItem, pDstItem; - HB_SIZE ulLen; + HB_SIZE nLen; HB_TRACE(HB_TR_DEBUG, ("hb_arrayCloneBody(%p, %p, %p)", pSrcBaseArray, pDstBaseArray, pClonedList)); @@ -1445,7 +1445,7 @@ static void hb_arrayCloneBody( PHB_BASEARRAY pSrcBaseArray, PHB_BASEARRAY pDstBa pDstBaseArray->uiClass = pSrcBaseArray->uiClass; - for( ulLen = pSrcBaseArray->nLen; ulLen; --ulLen, ++pSrcItem, ++pDstItem ) + for( nLen = pSrcBaseArray->nLen; nLen; --nLen, ++pSrcItem, ++pDstItem ) hb_cloneNested( pDstItem, pSrcItem, pClonedList ); } @@ -1518,9 +1518,9 @@ PHB_ITEM hb_arrayCloneTo( PHB_ITEM pDstArray, PHB_ITEM pSrcArray ) { PHB_NESTED_CLONED pClonedList, pCloned; PHB_BASEARRAY pSrcBaseArray = pSrcArray->item.asArray.value; - HB_SIZE ulSrcLen = pSrcBaseArray->nLen; + HB_SIZE nSrcLen = pSrcBaseArray->nLen; - hb_arrayNew( pDstArray, ulSrcLen ); + hb_arrayNew( pDstArray, nSrcLen ); pClonedList = ( PHB_NESTED_CLONED ) hb_xgrab( sizeof( HB_NESTED_CLONED ) ); pClonedList->value = ( void * ) pSrcBaseArray; pClonedList->pDest = pDstArray; diff --git a/harbour/src/vm/arrayshb.c b/harbour/src/vm/arrayshb.c index 45a6dd192e..bc8ae7558d 100644 --- a/harbour/src/vm/arrayshb.c +++ b/harbour/src/vm/arrayshb.c @@ -61,21 +61,21 @@ */ static void hb_arrayNewRagged( PHB_ITEM pArray, int iDimension ) { - HB_SIZE ulElements; + HB_SIZE nElements; HB_TRACE(HB_TR_DEBUG, ("hb_arrayNewRagged(%p, %d)", pArray, iDimension)); - ulElements = hb_parns( iDimension ); + nElements = hb_parns( iDimension ); /* create an array */ - hb_arrayNew( pArray, ulElements ); + hb_arrayNew( pArray, nElements ); if( ++iDimension <= hb_pcount() ) { /* call self recursively to create next dimensions */ - while( ulElements ) - hb_arrayNewRagged( hb_arrayGetItemPtr( pArray, ulElements-- ), iDimension ); + while( nElements ) + hb_arrayNewRagged( hb_arrayGetItemPtr( pArray, nElements-- ), iDimension ); } } @@ -169,12 +169,12 @@ HB_FUNC( AINS ) if( pArray ) { - HB_ISIZ lPos = hb_parns( 2 ); + HB_ISIZ nPos = hb_parns( 2 ); - if( lPos == 0 ) - lPos = 1; + if( nPos == 0 ) + nPos = 1; - hb_arrayIns( pArray, lPos ); + hb_arrayIns( pArray, nPos ); hb_itemReturn( pArray ); /* AIns() returns the array itself */ } @@ -186,12 +186,12 @@ HB_FUNC( ADEL ) if( pArray ) { - HB_ISIZ lPos = hb_parns( 2 ); + HB_ISIZ nPos = hb_parns( 2 ); - if( lPos == 0 ) - lPos = 1; + if( nPos == 0 ) + nPos = 1; - hb_arrayDel( pArray, lPos ); + hb_arrayDel( pArray, nPos ); hb_itemReturn( pArray ); /* ADel() returns the array itself */ } @@ -209,7 +209,7 @@ HB_FUNC( AFILL ) if( pValue ) { - HB_SIZE ulStart, ulCount; + HB_SIZE nStart, nCount; HB_ISIZ lStart = hb_parns( 3 ), lCount = hb_parns( 4 ); /* Explicy lCount of 0 - Nothing to do! */ @@ -225,17 +225,17 @@ HB_FUNC( AFILL ) { /* Clipper allows the Count to be negative, if start is 1, and corrects it to maximum elements. */ if( lStart == 1 ) - ulCount = 0; + nCount = 0; /* Clipper aborts if negative count and start is not at 1. */ else return; } - ulStart = ( HB_SIZE ) lStart; - ulCount = ( HB_SIZE ) lCount; + nStart = ( HB_SIZE ) lStart; + nCount = ( HB_SIZE ) lCount; hb_arrayFill( pArray, pValue, - HB_ISNUM( 3 ) ? &ulStart : NULL, - HB_ISNUM( 4 ) ? &ulCount : NULL ); + HB_ISNUM( 3 ) ? &nStart : NULL, + HB_ISNUM( 4 ) ? &nCount : NULL ); } } else @@ -256,12 +256,12 @@ HB_FUNC( ASCAN ) if( pArray && pValue ) { - HB_SIZE ulStart = hb_parns( 3 ); - HB_SIZE ulCount = hb_parns( 4 ); + HB_SIZE nStart = hb_parns( 3 ); + HB_SIZE nCount = hb_parns( 4 ); hb_retns( hb_arrayScan( pArray, pValue, - HB_ISNUM( 3 ) ? &ulStart : NULL, - HB_ISNUM( 4 ) ? &ulCount : NULL, + HB_ISNUM( 3 ) ? &nStart : NULL, + HB_ISNUM( 4 ) ? &nCount : NULL, HB_FALSE ) ); } else @@ -276,12 +276,12 @@ HB_FUNC( HB_ASCAN ) if( pArray && pValue ) { - HB_SIZE ulStart = hb_parns( 3 ); - HB_SIZE ulCount = hb_parns( 4 ); + HB_SIZE nStart = hb_parns( 3 ); + HB_SIZE nCount = hb_parns( 4 ); hb_retns( hb_arrayScan( pArray, pValue, - HB_ISNUM( 3 ) ? &ulStart : NULL, - HB_ISNUM( 4 ) ? &ulCount : NULL, + HB_ISNUM( 3 ) ? &nStart : NULL, + HB_ISNUM( 4 ) ? &nCount : NULL, hb_parl( 5 ) ) ); } else @@ -295,12 +295,12 @@ HB_FUNC( HB_RASCAN ) if( pArray && pValue ) { - HB_SIZE ulStart = hb_parns( 3 ); - HB_SIZE ulCount = hb_parns( 4 ); + HB_SIZE nStart = hb_parns( 3 ); + HB_SIZE nCount = hb_parns( 4 ); hb_retns( hb_arrayRevScan( pArray, pValue, - HB_ISNUM( 3 ) ? &ulStart : NULL, - HB_ISNUM( 4 ) ? &ulCount : NULL, + HB_ISNUM( 3 ) ? &nStart : NULL, + HB_ISNUM( 4 ) ? &nCount : NULL, hb_parl( 5 ) ) ); } else @@ -313,22 +313,22 @@ HB_FUNC( HB_AINS ) if( pArray ) { - HB_ISIZ lPos = hb_parns( 2 ); + HB_ISIZ nPos = hb_parns( 2 ); - if( lPos == 0 ) - lPos = 1; + if( nPos == 0 ) + nPos = 1; if( hb_parl( 4 ) ) { - HB_SIZE ulLen = hb_arrayLen( pArray ) + 1; - if( lPos >= 1 && ( HB_SIZE ) lPos <= ulLen ) - hb_arraySize( pArray, ulLen ); + HB_SIZE nLen = hb_arrayLen( pArray ) + 1; + if( nPos >= 1 && ( HB_SIZE ) nPos <= nLen ) + hb_arraySize( pArray, nLen ); } - if( hb_arrayIns( pArray, lPos ) ) + if( hb_arrayIns( pArray, nPos ) ) { if( ! HB_ISNIL( 3 ) ) - hb_arraySet( pArray, lPos, hb_param( 3, HB_IT_ANY ) ); + hb_arraySet( pArray, nPos, hb_param( 3, HB_IT_ANY ) ); } hb_itemReturn( pArray ); /* AIns() returns the array itself */ @@ -341,12 +341,12 @@ HB_FUNC( HB_ADEL ) if( pArray ) { - HB_ISIZ lPos = hb_parns( 2 ); + HB_ISIZ nPos = hb_parns( 2 ); - if( lPos == 0 ) - lPos = 1; + if( nPos == 0 ) + nPos = 1; - if( hb_arrayDel( pArray, lPos ) ) + if( hb_arrayDel( pArray, nPos ) ) { if( hb_parl( 3 ) ) hb_arraySize( pArray, hb_arrayLen( pArray ) - 1 ); @@ -366,13 +366,13 @@ HB_FUNC( AEVAL ) if( pArray && pBlock ) { - HB_SIZE ulStart = hb_parns( 3 ); - HB_SIZE ulCount = hb_parns( 4 ); + HB_SIZE nStart = hb_parns( 3 ); + HB_SIZE nCount = hb_parns( 4 ); hb_arrayEval( pArray, pBlock, - HB_ISNUM( 3 ) ? &ulStart : NULL, - HB_ISNUM( 4 ) ? &ulCount : NULL ); + HB_ISNUM( 3 ) ? &nStart : NULL, + HB_ISNUM( 4 ) ? &nCount : NULL ); hb_itemReturn( hb_stackItemFromBase( 1 ) ); /* AEval() returns the array itself */ } @@ -390,15 +390,15 @@ HB_FUNC( ACOPY ) /* CA-Cl*pper works this way. */ if( ! hb_arrayIsObject( pSrcArray ) && ! hb_arrayIsObject( pDstArray ) ) { - HB_SIZE ulStart = hb_parns( 3 ); - HB_SIZE ulCount = hb_parns( 4 ); - HB_SIZE ulTarget = hb_parns( 5 ); + HB_SIZE nStart = hb_parns( 3 ); + HB_SIZE nCount = hb_parns( 4 ); + HB_SIZE nTarget = hb_parns( 5 ); hb_arrayCopy( pSrcArray, pDstArray, - HB_ISNUM( 3 ) ? &ulStart : NULL, - HB_ISNUM( 4 ) ? &ulCount : NULL, - HB_ISNUM( 5 ) ? &ulTarget : NULL ); + HB_ISNUM( 3 ) ? &nStart : NULL, + HB_ISNUM( 4 ) ? &nCount : NULL, + HB_ISNUM( 5 ) ? &nTarget : NULL ); } hb_itemReturn( hb_stackItemFromBase( 2 ) ); /* ACopy() returns the target array */ diff --git a/harbour/src/vm/asort.c b/harbour/src/vm/asort.c index 47dee964d3..06f0394456 100644 --- a/harbour/src/vm/asort.c +++ b/harbour/src/vm/asort.c @@ -63,7 +63,7 @@ #include "hbvm.h" #include "hbstack.h" -static HB_BOOL hb_itemIsLess( PHB_ITEM pItem1, PHB_ITEM pItem2, PHB_ITEM pBlock, PHB_BASEARRAY pBaseArray, HB_SIZE ulLast ) +static HB_BOOL hb_itemIsLess( PHB_ITEM pItem1, PHB_ITEM pItem2, PHB_ITEM pBlock, PHB_BASEARRAY pBaseArray, HB_SIZE nLast ) { if( pBlock ) { @@ -73,7 +73,7 @@ static HB_BOOL hb_itemIsLess( PHB_ITEM pItem1, PHB_ITEM pItem2, PHB_ITEM pBlock, hb_vmPush( pItem2 ); hb_vmSend( 2 ); - if( pBaseArray->nLen <= ulLast ) + if( pBaseArray->nLen <= nLast ) return HB_FALSE; else { @@ -210,38 +210,38 @@ static void hb_arraySortQuick( PHB_BASEARRAY pBaseArray, HB_ISIZ lb, HB_ISIZ ub, } } -HB_BOOL hb_arraySort( PHB_ITEM pArray, HB_SIZE * pulStart, HB_SIZE * pulCount, PHB_ITEM pBlock ) +HB_BOOL hb_arraySort( PHB_ITEM pArray, HB_SIZE * pnStart, HB_SIZE * pnCount, PHB_ITEM pBlock ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySort(%p, %p, %p, %p)", pArray, pulStart, pulCount, pBlock)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySort(%p, %p, %p, %p)", pArray, pnStart, pnCount, pBlock)); if( HB_IS_ARRAY( pArray ) ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - HB_SIZE ulLen = pBaseArray->nLen; - HB_SIZE ulStart; - HB_SIZE ulCount; - HB_SIZE ulEnd; + HB_SIZE nLen = pBaseArray->nLen; + HB_SIZE nStart; + HB_SIZE nCount; + HB_SIZE nEnd; - if( pulStart && ( *pulStart >= 1 ) ) - ulStart = *pulStart; + if( pnStart && ( *pnStart >= 1 ) ) + nStart = *pnStart; else - ulStart = 1; + nStart = 1; - if( ulStart <= ulLen ) + if( nStart <= nLen ) { - if( pulCount && *pulCount >= 1 && ( *pulCount <= ulLen - ulStart ) ) - ulCount = *pulCount; + if( pnCount && *pnCount >= 1 && ( *pnCount <= nLen - nStart ) ) + nCount = *pnCount; else - ulCount = ulLen - ulStart + 1; + nCount = nLen - nStart + 1; - if( ulStart + ulCount > ulLen ) /* check range */ - ulCount = ulLen - ulStart + 1; + if( nStart + nCount > nLen ) /* check range */ + nCount = nLen - nStart + 1; - ulEnd = ulCount + ulStart - 2; + nEnd = nCount + nStart - 2; /* Optimize when only one or no element is to be sorted */ - if( ulCount > 1 ) - hb_arraySortQuick( pBaseArray, ulStart - 1, ulEnd, pBlock ); + if( nCount > 1 ) + hb_arraySortQuick( pBaseArray, nStart - 1, nEnd, pBlock ); } return HB_TRUE; @@ -256,12 +256,12 @@ HB_FUNC( ASORT ) if( pArray && ! hb_arrayIsObject( pArray ) ) { - HB_SIZE ulStart = hb_parns( 2 ); - HB_SIZE ulCount = hb_parns( 3 ); + HB_SIZE nStart = hb_parns( 2 ); + HB_SIZE nCount = hb_parns( 3 ); hb_arraySort( pArray, - HB_ISNUM( 2 ) ? &ulStart : NULL, - HB_ISNUM( 3 ) ? &ulCount : NULL, + HB_ISNUM( 2 ) ? &nStart : NULL, + HB_ISNUM( 3 ) ? &nCount : NULL, hb_param( 4, HB_IT_BLOCK ) ); hb_itemReturn( pArray ); /* ASort() returns the array itself */ diff --git a/harbour/src/vm/classes.c b/harbour/src/vm/classes.c index 3dde9f2f97..7b04e88020 100644 --- a/harbour/src/vm/classes.c +++ b/harbour/src/vm/classes.c @@ -442,7 +442,7 @@ static HB_USHORT hb_clsBucketPos( PHB_DYNS pMsg, HB_USHORT uiMask ) */ static HB_BOOL hb_clsDictRealloc( PCLASS pClass ) { - HB_SIZE ulNewHashKey, ulLimit, ul; + HB_SIZE nNewHashKey, nLimit, n; #ifdef HB_MSG_POOL HB_USHORT * puiMsgIdx; #else @@ -451,27 +451,27 @@ static HB_BOOL hb_clsDictRealloc( PCLASS pClass ) HB_TRACE(HB_TR_DEBUG, ("hb_clsDictRealloc(%p)", pClass)); - ulNewHashKey = ( HB_SIZE ) pClass->uiHashKey + 1; - ulLimit = ulNewHashKey << BUCKETBITS; + nNewHashKey = ( HB_SIZE ) pClass->uiHashKey + 1; + nLimit = nNewHashKey << BUCKETBITS; do { - ulNewHashKey <<= 1; - if( ulNewHashKey > HASH_KEYMAX ) + nNewHashKey <<= 1; + if( nNewHashKey > HASH_KEYMAX ) hb_errInternal( 6002, "Unable to realloc class message in __clsDictRealloc()", NULL, NULL ); #ifdef HB_MSG_POOL - puiMsgIdx = ( HB_USHORT * ) hb_xgrab( ( ulNewHashKey << BUCKETBITS ) * sizeof( HB_USHORT ) ); - memset( puiMsgIdx, 0, ( ulNewHashKey << BUCKETBITS ) * sizeof( HB_USHORT ) ); + puiMsgIdx = ( HB_USHORT * ) hb_xgrab( ( nNewHashKey << BUCKETBITS ) * sizeof( HB_USHORT ) ); + memset( puiMsgIdx, 0, ( nNewHashKey << BUCKETBITS ) * sizeof( HB_USHORT ) ); - for( ul = 0; ul < ulLimit; ul++ ) + for( n = 0; n < nLimit; n++ ) { - HB_USHORT uiMsg = pClass->puiMsgIdx[ ul ]; - if( pClass->puiMsgIdx[ ul ] ) + HB_USHORT uiMsg = pClass->puiMsgIdx[ n ]; + if( pClass->puiMsgIdx[ n ] ) { HB_USHORT uiBucket = BUCKETSIZE; HB_USHORT * puiIdx = puiMsgIdx + hb_clsBucketPos( - pClass->pMethods[ uiMsg ].pMessage, ulNewHashKey - 1 ); + pClass->pMethods[ uiMsg ].pMessage, nNewHashKey - 1 ); do { if( * puiIdx == 0 ) /* this message position is empty */ @@ -491,31 +491,31 @@ static HB_BOOL hb_clsDictRealloc( PCLASS pClass ) } } } - while( ul < ulLimit ); + while( n < nLimit ); - pClass->uiHashKey = ( HB_USHORT ) ( ulNewHashKey - 1 ); + pClass->uiHashKey = ( HB_USHORT ) ( nNewHashKey - 1 ); hb_xfree( pClass->puiMsgIdx ); pClass->puiMsgIdx = puiMsgIdx; #else - pNewMethods = ( PMETHOD ) hb_xgrab( ( ulNewHashKey << BUCKETBITS ) * sizeof( METHOD ) ); - memset( pNewMethods, 0, ( ulNewHashKey << BUCKETBITS ) * sizeof( METHOD ) ); + pNewMethods = ( PMETHOD ) hb_xgrab( ( nNewHashKey << BUCKETBITS ) * sizeof( METHOD ) ); + memset( pNewMethods, 0, ( nNewHashKey << BUCKETBITS ) * sizeof( METHOD ) ); - for( ul = 0; ul < ulLimit; ul++ ) + for( n = 0; n < nLimit; n++ ) { - PHB_DYNS pMessage = ( PHB_DYNS ) pClass->pMethods[ ul ].pMessage; + PHB_DYNS pMessage = ( PHB_DYNS ) pClass->pMethods[ n ].pMessage; if( pMessage ) { - PMETHOD pMethod = pNewMethods + hb_clsBucketPos( pMessage, ulNewHashKey - 1 ); + PMETHOD pMethod = pNewMethods + hb_clsBucketPos( pMessage, nNewHashKey - 1 ); HB_USHORT uiBucket = BUCKETSIZE; do { if( ! pMethod->pMessage ) /* this message position is empty */ { - memcpy( pMethod, pClass->pMethods + ul, sizeof( METHOD ) ); + memcpy( pMethod, pClass->pMethods + n, sizeof( METHOD ) ); break; } ++pMethod; @@ -530,9 +530,9 @@ static HB_BOOL hb_clsDictRealloc( PCLASS pClass ) } } } - while( ul < ulLimit ); + while( n < nLimit ); - pClass->uiHashKey = ( HB_USHORT ) ( ulNewHashKey - 1 ); + pClass->uiHashKey = ( HB_USHORT ) ( nNewHashKey - 1 ); hb_xfree( pClass->pMethods ); pClass->pMethods = pNewMethods; #endif @@ -542,23 +542,23 @@ static HB_BOOL hb_clsDictRealloc( PCLASS pClass ) static void hb_clsDictInit( PCLASS pClass, HB_USHORT uiHashKey ) { - HB_SIZE ulSize; + HB_SIZE nSize; HB_TRACE(HB_TR_DEBUG, ("hb_clsDictInit(%p,%hu)", pClass, uiHashKey)); pClass->uiHashKey = uiHashKey; #ifdef HB_MSG_POOL - ulSize = ( ( ( HB_SIZE ) uiHashKey + 1 ) << BUCKETBITS ) * sizeof( HB_USHORT ); - pClass->puiMsgIdx = ( HB_USHORT * ) hb_xgrab( ulSize ); - memset( pClass->puiMsgIdx, 0, ulSize ); + nSize = ( ( ( HB_SIZE ) uiHashKey + 1 ) << BUCKETBITS ) * sizeof( HB_USHORT ); + pClass->puiMsgIdx = ( HB_USHORT * ) hb_xgrab( nSize ); + memset( pClass->puiMsgIdx, 0, nSize ); pClass->uiMethodCount = 1; pClass->pMethods = ( PMETHOD ) hb_xgrab( sizeof( METHOD ) ); memset( pClass->pMethods, 0, sizeof( METHOD ) ); #else - ulSize = ( ( ( HB_SIZE ) uiHashKey + 1 ) << BUCKETBITS ) * sizeof( METHOD ); - pClass->pMethods = ( PMETHOD ) hb_xgrab( ulSize ); - memset( pClass->pMethods, 0, ulSize ); + nSize = ( ( ( HB_SIZE ) uiHashKey + 1 ) << BUCKETBITS ) * sizeof( METHOD ); + pClass->pMethods = ( PMETHOD ) hb_xgrab( nSize ); + memset( pClass->pMethods, 0, nSize ); #endif } @@ -820,7 +820,7 @@ static HB_USHORT hb_clsFindClassDataOffset( PCLASS pClass, PMETHOD pNewMethod ) uiData = hb_clsFindRealClassDataOffset( pNewMethod ); if( uiData ) { - HB_SIZE ulLimit = hb_clsMthNum( pClass ); + HB_SIZE nLimit = hb_clsMthNum( pClass ); PMETHOD pMethod = pClass->pMethods; do { @@ -834,7 +834,7 @@ static HB_USHORT hb_clsFindClassDataOffset( PCLASS pClass, PMETHOD pNewMethod ) } ++pMethod; } - while( --ulLimit ); + while( --nLimit ); } return 0; @@ -909,7 +909,7 @@ static HB_BOOL hb_clsUpdateHiddenMessages( PMETHOD pSrcMethod, PMETHOD pDstMetho static void hb_clsCopyClass( PCLASS pClsDst, PCLASS pClsSrc ) { PMETHOD pMethod; - HB_SIZE ulLimit; + HB_SIZE nLimit; HB_TRACE(HB_TR_DEBUG, ("hb_clsCopyClass(%p,%p)", pClsDst, pClsSrc)); @@ -930,12 +930,12 @@ static void hb_clsCopyClass( PCLASS pClsDst, PCLASS pClsSrc ) if( pClsSrc->uiInitDatas ) { - HB_SIZE ulSize = ( HB_SIZE ) pClsSrc->uiInitDatas * sizeof( INITDATA ); + HB_SIZE nSize = ( HB_SIZE ) pClsSrc->uiInitDatas * sizeof( INITDATA ); HB_USHORT uiData; pClsDst->uiInitDatas = pClsSrc->uiInitDatas; - pClsDst->pInitData = ( PINITDATA ) hb_xgrab( ulSize ); - memcpy( pClsDst->pInitData, pClsSrc->pInitData, ulSize ); + pClsDst->pInitData = ( PINITDATA ) hb_xgrab( nSize ); + memcpy( pClsDst->pInitData, pClsSrc->pInitData, nSize ); for( uiData = 0; uiData < pClsDst->uiInitDatas; ++uiData ) { if( pClsDst->pInitData[ uiData ].uiType == HB_OO_MSG_INITIALIZED ) @@ -945,15 +945,15 @@ static void hb_clsCopyClass( PCLASS pClsDst, PCLASS pClsSrc ) } } - ulLimit = hb_clsMthNum( pClsSrc ); + nLimit = hb_clsMthNum( pClsSrc ); #ifdef HB_MSG_POOL memcpy( pClsDst->puiMsgIdx, pClsSrc->puiMsgIdx, ( ( ( HB_SIZE ) pClsSrc->uiHashKey + 1 ) << BUCKETBITS ) * sizeof( HB_USHORT ) ); pClsDst->uiMethodCount = pClsSrc->uiMethodCount; pClsDst->pMethods = ( PMETHOD ) hb_xrealloc( pClsDst->pMethods, - ulLimit * sizeof( METHOD ) ); + nLimit * sizeof( METHOD ) ); #endif - memcpy( pClsDst->pMethods, pClsSrc->pMethods, ulLimit * sizeof( METHOD ) ); + memcpy( pClsDst->pMethods, pClsSrc->pMethods, nLimit * sizeof( METHOD ) ); pClsDst->uiMethods = pClsSrc->uiMethods; pMethod = pClsDst->pMethods; @@ -966,7 +966,7 @@ static void hb_clsCopyClass( PCLASS pClsDst, PCLASS pClsSrc ) } ++pMethod; } - while( --ulLimit ); + while( --nLimit ); } static HB_BOOL hb_clsIsFriendSymbol( PCLASS pClass, PHB_SYMB pSym ) @@ -2085,19 +2085,19 @@ HB_BOOL hb_objGetVarRef( PHB_ITEM pObject, PHB_SYMB pMessage, HB_USHORT uiObjClass = pObject->item.asArray.value->uiClass; PCLASS pClass = s_pClasses[ pStack->uiClass ]; PMETHOD pMethod = pClass->pMethods + pStack->uiMethod; - HB_SIZE ulIndex = pMethod->uiData; + HB_SIZE nIndex = pMethod->uiData; if( pStack->uiClass != uiObjClass ) - ulIndex += hb_clsParentInstanceOffset( s_pClasses[ uiObjClass ], + nIndex += hb_clsParentInstanceOffset( s_pClasses[ uiObjClass ], s_pClasses[ pMethod->uiSprClass ]->pClassSym ); else - ulIndex += pMethod->uiOffset; + nIndex += 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 */ + if( nIndex > hb_arrayLen( pObject ) ) /* Resize needed */ + hb_arraySize( pObject, nIndex ); /* Make large enough */ - return hb_arrayGetItemRef( pObject, ulIndex, hb_stackReturnItem() ); + return hb_arrayGetItemRef( pObject, nIndex, hb_stackReturnItem() ); } else if( pExecSym->value.pFunPtr == HB_FUNCNAME( msgSetClsData ) ) { @@ -2152,7 +2152,7 @@ static void hb_objSupperDestructorCall( PHB_ITEM pObject, PCLASS pClass ) { HB_STACK_TLS_PRELOAD PMETHOD pMethod = pClass->pMethods; - HB_SIZE ulLimit = hb_clsMthNum( pClass ); + HB_SIZE nLimit = hb_clsMthNum( pClass ); char * pcClasses; HB_USHORT uiClass; @@ -2174,7 +2174,7 @@ static void hb_objSupperDestructorCall( PHB_ITEM pObject, PCLASS pClass ) } ++pMethod; } - while( --ulLimit ); + while( --nLimit ); for( uiClass = s_uiClasses; uiClass; --uiClass ) { @@ -3172,11 +3172,11 @@ static HB_USHORT hb_clsNew( const char * szClassName, HB_USHORT uiDatas, } else if( !hb_clsHasParent( pNewCls, pSprCls->pClassSym ) ) { - HB_SIZE ul, ulLimit; + HB_SIZE n, nLimit; HB_USHORT nLenClsDatas; /* create class data translation tables */ - nLenClsDatas = ( HB_USHORT ) hb_itemSize( pSprCls->pClassDatas ); + nLenClsDatas = ( HB_USHORT ) hb_itemSize( pSprCls->pClassDatas ); if( nLenClsDatas ) { if( nLenClsDatas > uiClassDataSize ) @@ -3193,22 +3193,22 @@ static HB_USHORT hb_clsNew( const char * szClassName, HB_USHORT uiDatas, } /* Copy super class handles */ - ulLimit = hb_clsMthNum( pSprCls ); - for( ul = 0; ul < ulLimit; ++ul ) + nLimit = hb_clsMthNum( pSprCls ); + for( n = 0; n < nLimit; ++n ) { - if( pSprCls->pMethods[ ul ].pMessage && - pSprCls->pMethods[ ul ].pFuncSym == &s___msgSuper ) + if( pSprCls->pMethods[ n ].pMessage && + pSprCls->pMethods[ n ].pFuncSym == &s___msgSuper ) { - PCLASS pCls = s_pClasses[ pSprCls->pMethods[ ul ].uiSprClass ]; + PCLASS pCls = s_pClasses[ pSprCls->pMethods[ n ].uiSprClass ]; pMethod = hb_clsAllocMsg( pNewCls, - pSprCls->pMethods[ ul ].pMessage ); + pSprCls->pMethods[ n ].pMessage ); if( ! pMethod ) return 0; if( pMethod->pMessage == NULL ) { pNewCls->uiMethods++; - memcpy( pMethod, pSprCls->pMethods + ul, sizeof( METHOD ) ); + memcpy( pMethod, pSprCls->pMethods + n, sizeof( METHOD ) ); pMethod->uiOffset = pNewCls->uiDatas; pNewCls->uiDatas += pCls->uiDatas - pCls->uiDataFirst; } @@ -3250,12 +3250,12 @@ static HB_USHORT hb_clsNew( const char * szClassName, HB_USHORT uiDatas, } /* Now working on other methods */ - ulLimit = hb_clsMthNum( pSprCls ); - for( ul = 0; ul < ulLimit; ++ul ) + nLimit = hb_clsMthNum( pSprCls ); + for( n = 0; n < nLimit; ++n ) { - if( pSprCls->pMethods[ ul ].pMessage ) + if( pSprCls->pMethods[ n ].pMessage ) { - pMethod = hb_clsAllocMsg( pNewCls, pSprCls->pMethods[ ul ].pMessage ); + pMethod = hb_clsAllocMsg( pNewCls, pSprCls->pMethods[ n ].pMessage ); if( ! pMethod ) return 0; @@ -3264,7 +3264,7 @@ static HB_USHORT hb_clsNew( const char * szClassName, HB_USHORT uiDatas, { /* Now, we can increment the msg count */ pNewCls->uiMethods++; - memcpy( pMethod, pSprCls->pMethods + ul, sizeof( METHOD ) ); + memcpy( pMethod, pSprCls->pMethods + n, sizeof( METHOD ) ); if( ! hb_clsUpdateHiddenMessages( pMethod, pMethod, pNewCls ) ) { if( pMethod->pFuncSym == &s___msgSetClsData || @@ -3300,11 +3300,11 @@ static HB_USHORT hb_clsNew( const char * szClassName, HB_USHORT uiDatas, } else { - if( pSprCls->pMethods[ ul ].uiScope & + if( pSprCls->pMethods[ n ].uiScope & ( HB_OO_CLSTP_OVERLOADED | HB_OO_CLSTP_NONVIRTUAL ) ) pMethod->uiScope |= HB_OO_CLSTP_OVERLOADED; - hb_clsUpdateHiddenMessages( pSprCls->pMethods + ul, pMethod, pNewCls ); + hb_clsUpdateHiddenMessages( pSprCls->pMethods + n, pMethod, pNewCls ); } } } @@ -4018,20 +4018,20 @@ HB_FUNC( __CLASSSEL ) { PCLASS pClass = s_pClasses[ uiClass ]; PMETHOD pMethod = pClass->pMethods; - HB_SIZE ulLimit = hb_clsMthNum( pClass ), ulPos = 0; + HB_SIZE nLimit = hb_clsMthNum( pClass ), nPos = 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 ); + hb_arraySetC( pReturn, ++nPos, pMethod->pMessage->pSymbol->szName ); ++pMethod; } - while( --ulLimit ); + while( --nLimit ); - if( ulPos < ( HB_SIZE ) pClass->uiMethods ) - hb_arraySize( pReturn, ulPos ); + if( nPos < ( HB_SIZE ) pClass->uiMethods ) + hb_arraySize( pReturn, nPos ); } hb_itemReturnRelease( pReturn ); @@ -4232,7 +4232,7 @@ HB_FUNC_STATIC( msgClassSel ) PHB_ITEM pReturn, pItem; PCLASS pClass = s_pClasses[ uiClass ]; PMETHOD pMethod = pClass->pMethods; - HB_SIZE ulLimit = hb_clsMthNum( pClass ), ulPos = 0; + HB_SIZE nLimit = hb_clsMthNum( pClass ), nPos = 0; HB_USHORT nParam, nScope; HB_BOOL lFull; @@ -4255,7 +4255,7 @@ HB_FUNC_STATIC( msgClassSel ) { if( lFull ) { - pItem = hb_arrayGetItemPtr( pReturn, ++ulPos ); + pItem = hb_arrayGetItemPtr( pReturn, ++nPos ); hb_arrayNew( pItem, 4 ); hb_arraySetC( pItem, HB_OO_DATA_SYMBOL, pMethod->pMessage->pSymbol->szName ); @@ -4263,17 +4263,17 @@ HB_FUNC_STATIC( msgClassSel ) hb_arraySetNI( pItem, HB_OO_DATA_SCOPE, pMethod->uiScope ); } else - hb_arraySetC( pReturn, ++ulPos, + hb_arraySetC( pReturn, ++nPos, pMethod->pMessage->pSymbol->szName ); } } } ++pMethod; } - while( --ulLimit && ulPos < ( HB_SIZE ) pClass->uiMethods ); + while( --nLimit && nPos < ( HB_SIZE ) pClass->uiMethods ); - if( ulPos < ( HB_SIZE ) pClass->uiMethods ) - hb_arraySize( pReturn, ulPos ); + if( nPos < ( HB_SIZE ) pClass->uiMethods ) + hb_arraySize( pReturn, nPos ); hb_itemReturnRelease( pReturn ); } } @@ -4695,19 +4695,19 @@ HB_FUNC_STATIC( msgGetData ) PCLASS pClass = s_pClasses[ uiClass ]; PMETHOD pMethod = pClass->pMethods + hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod; - HB_SIZE ulIndex = pMethod->uiData; + HB_SIZE nIndex = pMethod->uiData; if( uiClass != uiObjClass ) { - ulIndex += hb_clsParentInstanceOffset( s_pClasses[ uiObjClass ], + nIndex += hb_clsParentInstanceOffset( s_pClasses[ uiObjClass ], s_pClasses[ pMethod->uiSprClass ]->pClassSym ); } else { - ulIndex += pMethod->uiOffset; + nIndex += pMethod->uiOffset; } - hb_arrayGet( pObject, ulIndex, hb_stackReturnItem() ); + hb_arrayGet( pObject, nIndex, hb_stackReturnItem() ); } } @@ -4729,20 +4729,20 @@ HB_FUNC_STATIC( msgSetData ) PCLASS pClass = s_pClasses[ uiClass ]; PMETHOD pMethod = pClass->pMethods + hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod; - HB_SIZE ulIndex = pMethod->uiData; + HB_SIZE nIndex = pMethod->uiData; if( uiClass != uiObjClass ) { - ulIndex += hb_clsParentInstanceOffset( s_pClasses[ uiObjClass ], + nIndex += hb_clsParentInstanceOffset( s_pClasses[ uiObjClass ], s_pClasses[ pMethod->uiSprClass ]->pClassSym ); } else { - ulIndex += pMethod->uiOffset; + nIndex += pMethod->uiOffset; } if( !pReturn ) - hb_arrayGet( pObject, ulIndex, hb_stackReturnItem() ); + hb_arrayGet( pObject, nIndex, hb_stackReturnItem() ); else { @@ -4759,9 +4759,9 @@ HB_FUNC_STATIC( msgSetData ) } /* 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 ); + if( nIndex > hb_arrayLen( pObject ) ) /* Resize needed ? */ + hb_arraySize( pObject, nIndex ); /* Make large enough */ + hb_arraySet( pObject, nIndex, pReturn ); hb_itemReturnForward( pReturn ); } } @@ -4857,53 +4857,53 @@ HB_FUNC( __CLSGETPROPERTIES ) { PCLASS pClass = s_pClasses[ uiClass ]; PMETHOD pMethod; - HB_SIZE ulLimit, ulCount; + HB_SIZE nLimit, nCount; HB_USHORT uiScope = HB_OO_CLSTP_PERSIST; if( hb_parl( 2 ) ) uiScope |= HB_OO_CLSTP_EXPORTED; - ulCount = 0; - ulLimit = hb_clsMthNum( pClass ); + nCount = 0; + nLimit = hb_clsMthNum( pClass ); pMethod = pClass->pMethods; do { if( pMethod->pMessage && ( pMethod->uiScope & uiScope ) != 0 ) { if( ( pMethod->uiScope & HB_OO_CLSTP_PERSIST ) != 0 ) - ++ulCount; + ++nCount; else if( pMethod->pMessage->pSymbol->szName[ 0 ] == '_' ) { PHB_DYNS pMsg = hb_dynsymFind( pMethod->pMessage->pSymbol->szName + 1 ); if( pMsg && hb_clsFindMsg( pClass, pMsg ) ) - ++ulCount; + ++nCount; } } ++pMethod; } - while( --ulLimit ); + while( --nLimit ); - hb_arrayNew( pReturn, ulCount ); + hb_arrayNew( pReturn, nCount ); - ulCount = 0; - ulLimit = hb_clsMthNum( pClass ); + nCount = 0; + nLimit = hb_clsMthNum( pClass ); pMethod = pClass->pMethods; do { if( pMethod->pMessage && ( pMethod->uiScope & uiScope ) != 0 ) { if( ( pMethod->uiScope & HB_OO_CLSTP_PERSIST ) != 0 ) - hb_arraySetC( pReturn, ++ulCount, pMethod->pMessage->pSymbol->szName ); + hb_arraySetC( pReturn, ++nCount, pMethod->pMessage->pSymbol->szName ); else if( pMethod->pMessage->pSymbol->szName[ 0 ] == '_' ) { PHB_DYNS pMsg = hb_dynsymFind( pMethod->pMessage->pSymbol->szName + 1 ); if( pMsg && hb_clsFindMsg( pClass, pMsg ) ) - hb_arraySetC( pReturn, ++ulCount, pMethod->pMessage->pSymbol->szName + 1 ); + hb_arraySetC( pReturn, ++nCount, pMethod->pMessage->pSymbol->szName + 1 ); } } ++pMethod; } - while( --ulLimit ); + while( --nLimit ); } hb_itemReturnRelease( pReturn ); diff --git a/harbour/src/vm/cmdarg.c b/harbour/src/vm/cmdarg.c index 909837f009..83a3f635c7 100644 --- a/harbour/src/vm/cmdarg.c +++ b/harbour/src/vm/cmdarg.c @@ -348,16 +348,16 @@ static char * hb_cmdargGet( const char * pszName, HB_BOOL bRetValue ) { if( bRetValue ) { - HB_SIZE ulLen; + HB_SIZE nLen; pszNext += i; /* Skip value separator colon. */ if( *pszNext == ':' ) pszNext++; - ulLen = pszEnd > pszNext ? pszEnd - pszNext : 0; - pszRetVal = ( char * ) hb_xgrab( ulLen + 1 ); - hb_strncpy( pszRetVal, pszNext, ulLen ); + nLen = pszEnd > pszNext ? pszEnd - pszNext : 0; + pszRetVal = ( char * ) hb_xgrab( nLen + 1 ); + hb_strncpy( pszRetVal, pszNext, nLen ); } else pszRetVal = ( char * ) ""; @@ -483,21 +483,21 @@ HB_FUNC( HB_CMDLINE ) char** argv = hb_cmdargARGV(); int argc = hb_cmdargARGC(); char * pszBuffer, * ptr; - HB_SIZE ulLen; + HB_SIZE nLen; int iArg; - ulLen = 0; + nLen = 0; for( iArg = 1; iArg < argc; iArg++ ) - ulLen += strlen( argv[ iArg ] ) + 1; + nLen += strlen( argv[ iArg ] ) + 1; - if( ulLen ) + if( nLen ) { - ptr = pszBuffer = ( char * ) hb_xgrab( ulLen ); + ptr = pszBuffer = ( char * ) hb_xgrab( nLen ); for( iArg = 1; iArg < argc; iArg++ ) { - ulLen = strlen( argv[ iArg ] ); - memcpy( ptr, argv[ iArg ], ulLen ); - ptr += ulLen; + nLen = strlen( argv[ iArg ] ); + memcpy( ptr, argv[ iArg ], nLen ); + ptr += nLen; *ptr++ = ' '; } *--ptr = '\0'; diff --git a/harbour/src/vm/codebloc.c b/harbour/src/vm/codebloc.c index 0e295694b6..ff05a77a28 100644 --- a/harbour/src/vm/codebloc.c +++ b/harbour/src/vm/codebloc.c @@ -142,14 +142,14 @@ HB_CODEBLOCK_PTR hb_codeblockNew( const HB_BYTE * pBuffer, HB_USHORT uiLocals, const HB_BYTE * pLocalPosTable, PHB_SYMB pSymbols, - HB_SIZE ulLen ) + HB_SIZE nLen ) { HB_STACK_TLS_PRELOAD HB_CODEBLOCK_PTR pCBlock; PHB_ITEM pLocals, pBase; HB_BYTE * pCode; - HB_TRACE(HB_TR_DEBUG, ("hb_codeblockNew(%p, %hu, %p, %p, %" HB_PFS "u)", pBuffer, uiLocals, pLocalPosTable, pSymbols, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_codeblockNew(%p, %hu, %p, %p, %" HB_PFS "u)", pBuffer, uiLocals, pLocalPosTable, pSymbols, nLen)); /* * allocate memory for code block body and detach items hb_gcAllocRaw() @@ -157,15 +157,15 @@ HB_CODEBLOCK_PTR hb_codeblockNew( const HB_BYTE * pBuffer, * calling hb_gcLock()/hb_gcUnlock(). [druzus] */ - if( ulLen ) + if( nLen ) { /* * 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 = ( HB_BYTE * ) hb_xgrab( ulLen ); - memcpy( pCode, pBuffer, ulLen ); + pCode = ( HB_BYTE * ) hb_xgrab( nLen ); + memcpy( pCode, pBuffer, nLen ); } else { @@ -241,7 +241,7 @@ HB_CODEBLOCK_PTR hb_codeblockNew( const HB_BYTE * pBuffer, pCBlock = ( HB_CODEBLOCK_PTR ) hb_gcAllocRaw( sizeof( HB_CODEBLOCK ), &s_gcCodeblockFuncs ); pCBlock->pCode = pCode; - pCBlock->dynBuffer = ulLen != 0; + pCBlock->dynBuffer = nLen != 0; pCBlock->pDefSymb = pBase->item.asSymbol.stackstate->uiClass ? hb_clsMethodSym( pBase ) : pBase->item.asSymbol.value; pCBlock->pSymbols = pSymbols; @@ -254,14 +254,14 @@ HB_CODEBLOCK_PTR hb_codeblockNew( const HB_BYTE * pBuffer, return pCBlock; } -HB_CODEBLOCK_PTR hb_codeblockMacroNew( const HB_BYTE * pBuffer, HB_SIZE ulLen ) +HB_CODEBLOCK_PTR hb_codeblockMacroNew( const HB_BYTE * pBuffer, HB_SIZE nLen ) { HB_STACK_TLS_PRELOAD HB_CODEBLOCK_PTR pCBlock; PHB_ITEM pBase; HB_BYTE * pCode; - HB_TRACE(HB_TR_DEBUG, ("hb_codeblockMacroNew(%p, %" HB_PFS "u)", pBuffer, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_codeblockMacroNew(%p, %" HB_PFS "u)", pBuffer, nLen)); /* * The codeblock pcode is stored in dynamically allocated memory that @@ -273,8 +273,8 @@ HB_CODEBLOCK_PTR hb_codeblockMacroNew( const HB_BYTE * pBuffer, HB_SIZE ulLen ) * to be safe for automatic GC activation in hb_xgrab() without * calling hb_gcLock()/hb_gcUnlock(). [druzus] */ - pCode = ( HB_BYTE * ) hb_xgrab( ulLen ); - memcpy( pCode, pBuffer, ulLen ); + pCode = ( HB_BYTE * ) hb_xgrab( nLen ); + memcpy( pCode, pBuffer, nLen ); pCBlock = ( HB_CODEBLOCK_PTR ) hb_gcAllocRaw( sizeof( HB_CODEBLOCK ), &s_gcCodeblockFuncs ); pBase = hb_stackBaseItem(); diff --git a/harbour/src/vm/debug.c b/harbour/src/vm/debug.c index 2bf9830b57..39b1d0d011 100644 --- a/harbour/src/vm/debug.c +++ b/harbour/src/vm/debug.c @@ -110,25 +110,25 @@ * $FuncName$ AddToArray( , , ) * $Description$ Add to array at pos * $End$ */ -static void AddToArray( PHB_ITEM pItem, PHB_ITEM pReturn, HB_SIZE ulPos ) +static void AddToArray( PHB_ITEM pItem, PHB_ITEM pReturn, HB_SIZE nPos ) { - HB_TRACE(HB_TR_DEBUG, ("AddToArray(%p, %p, %" HB_PFS "u)", pItem, pReturn, ulPos)); + HB_TRACE(HB_TR_DEBUG, ("AddToArray(%p, %p, %" HB_PFS "u)", pItem, pReturn, nPos)); if( HB_IS_SYMBOL( pItem ) ) { /* Symbol is pushed as text */ - PHB_ITEM pArrayItem = hb_arrayGetItemPtr( pReturn, ulPos ); + PHB_ITEM pArrayItem = hb_arrayGetItemPtr( pReturn, nPos ); if( pArrayItem ) { - HB_SIZE ulLen = strlen( pItem->item.asSymbol.value->szName ) + 2; - char * szBuff = ( char * ) hb_xgrab( ulLen + 1 ); + HB_SIZE nLen = strlen( pItem->item.asSymbol.value->szName ) + 2; + char * szBuff = ( char * ) hb_xgrab( nLen + 1 ); - hb_snprintf( szBuff, ulLen + 1, "[%s]", pItem->item.asSymbol.value->szName ); - hb_itemPutCLPtr( pArrayItem, szBuff, ulLen ); + hb_snprintf( szBuff, nLen + 1, "[%s]", pItem->item.asSymbol.value->szName ); + hb_itemPutCLPtr( pArrayItem, szBuff, nLen ); } } else /* Normal types */ - hb_itemArrayPut( pReturn, ulPos, pItem ); + hb_itemArrayPut( pReturn, nPos, pItem ); } /* $Doc$ @@ -147,13 +147,13 @@ HB_FUNC( __DBGVMSTKGCOUNT ) HB_FUNC( __DBGVMSTKGLIST ) { PHB_ITEM pReturn; - HB_ISIZ ulLen = hb_stackTopOffset(); - HB_ISIZ ulPos; + HB_ISIZ nLen = hb_stackTopOffset(); + HB_ISIZ nPos; - pReturn = hb_itemArrayNew( ulLen ); /* Create a transfer array */ + pReturn = hb_itemArrayNew( nLen ); /* Create a transfer array */ - for( ulPos = 0; ulPos < ulLen; ++ulPos ) - AddToArray( hb_stackItem( ulPos ), pReturn, ulPos + 1 ); + for( nPos = 0; nPos < nLen; ++nPos ) + AddToArray( hb_stackItem( nPos ), pReturn, nPos + 1 ); hb_itemReturnRelease( pReturn ); } @@ -206,16 +206,16 @@ HB_FUNC( __DBGVMSTKLCOUNT ) HB_FUNC( __DBGVMSTKLLIST ) { PHB_ITEM pReturn; - HB_ISIZ ulLen, ul; + HB_ISIZ nLen, n; HB_ISIZ 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 ); + nLen = lBaseOffset - lPrevOffset - 3; + pReturn = hb_itemArrayNew( nLen ); /* Create a transfer array */ + for( n = 0; n < nLen; ++n ) + AddToArray( hb_stackItem( lPrevOffset + n ), pReturn, n + 1 ); hb_itemReturnRelease( pReturn ); } diff --git a/harbour/src/vm/estack.c b/harbour/src/vm/estack.c index ad55734350..2eef22d2cd 100644 --- a/harbour/src/vm/estack.c +++ b/harbour/src/vm/estack.c @@ -290,15 +290,15 @@ void * hb_stackGetTSD( PHB_TSD pTSD ) #else if( pTSD->iHandle == 0 ) { - HB_SIZE ulSize = ( hb_stack.iTSD + 2 ) * sizeof( HB_TSD_HOLDER ); + HB_SIZE nSize = ( hb_stack.iTSD + 2 ) * sizeof( HB_TSD_HOLDER ); if( hb_stack.iTSD == 0 ) { - hb_stack.pTSD = ( PHB_TSD_HOLDER ) hb_xgrab( ulSize ); - memset( hb_stack.pTSD, 0, ulSize ); + hb_stack.pTSD = ( PHB_TSD_HOLDER ) hb_xgrab( nSize ); + memset( hb_stack.pTSD, 0, nSize ); } else { - hb_stack.pTSD = ( PHB_TSD_HOLDER ) hb_xrealloc( hb_stack.pTSD, ulSize ); + hb_stack.pTSD = ( PHB_TSD_HOLDER ) hb_xrealloc( hb_stack.pTSD, nSize ); } pTSD->iHandle = ++hb_stack.iTSD; #endif @@ -583,13 +583,13 @@ void hb_stackDec( void ) } #undef hb_stackDecrease -void hb_stackDecrease( HB_SIZE ulItems ) +void hb_stackDecrease( HB_SIZE nItems ) { HB_STACK_TLS_PRELOAD HB_TRACE(HB_TR_DEBUG, ("hb_stackDecrease()")); - if( ( hb_stack.pPos -= ulItems ) <= hb_stack.pBase ) + if( ( hb_stack.pPos -= nItems ) <= hb_stack.pBase ) hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL ); } @@ -1255,11 +1255,11 @@ static void hb_stackIsMemvarRef( PHB_STACK pStack ) { /* 1. Mark all hidden memvars (PRIVATEs and PUBLICs) */ PHB_PRIVATE_STACK pPrivateStack = &pStack->privates; - HB_SIZE ulCount = pPrivateStack->count; + HB_SIZE nCount = pPrivateStack->count; - while( ulCount ) + while( nCount ) { - PHB_ITEM pMemvar = pPrivateStack->stack[ --ulCount ].pPrevMemvar; + PHB_ITEM pMemvar = pPrivateStack->stack[ --nCount ].pPrevMemvar; if( pMemvar && HB_IS_GCITEM( pMemvar ) ) hb_gcItemRef( pMemvar ); } diff --git a/harbour/src/vm/extend.c b/harbour/src/vm/extend.c index 2499f78667..07536b80cd 100644 --- a/harbour/src/vm/extend.c +++ b/harbour/src/vm/extend.c @@ -145,20 +145,20 @@ HB_ULONG hb_parinfo( int iParam ) } } -HB_SIZE hb_parinfa( int iParamNum, HB_SIZE uiArrayIndex ) +HB_SIZE hb_parinfa( int iParamNum, HB_SIZE nArrayIndex ) { PHB_ITEM pArray; - HB_TRACE(HB_TR_DEBUG, ("hb_parinfa(%d, %" HB_PFS "u)", iParamNum, uiArrayIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_parinfa(%d, %" HB_PFS "u)", iParamNum, nArrayIndex)); pArray = hb_param( iParamNum, HB_IT_ARRAY ); if( pArray ) { - if( uiArrayIndex == 0 ) + if( nArrayIndex == 0 ) return hb_arrayLen( pArray ); else - return ( HB_ISIZ ) hb_arrayGetType( pArray, uiArrayIndex ); + return ( HB_ISIZ ) hb_arrayGetType( pArray, nArrayIndex ); } else return 0; @@ -249,7 +249,7 @@ const char * hb_parcx( int iParam ) return ""; } -HB_SIZE hb_parclen( int iParam ) +HB_SIZE hb_parclen( int iParam ) { HB_STACK_TLS_PRELOAD @@ -273,7 +273,7 @@ HB_SIZE hb_parclen( int iParam ) terminating zero byte, and it only works for parameters passed by reference. [vszakats] */ -HB_SIZE hb_parcsiz( int iParam ) +HB_SIZE hb_parcsiz( int iParam ) { HB_STACK_TLS_PRELOAD @@ -783,13 +783,13 @@ const char * hb_parvc( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - pItem = hb_arrayGetItemPtr( pItem, ulArrayIndex ); + pItem = hb_arrayGetItemPtr( pItem, nArrayIndex ); return pItem && HB_IS_STRING( pItem ) ? hb_itemGetCPtr( pItem ) : NULL; } } @@ -815,20 +815,20 @@ const char * hb_parvcx( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetCPtr( pItem, ulArrayIndex ); + return hb_arrayGetCPtr( pItem, nArrayIndex ); } } return ""; } -HB_SIZE hb_parvclen( int iParam, ... ) +HB_SIZE hb_parvclen( int iParam, ... ) { HB_STACK_TLS_PRELOAD @@ -846,13 +846,13 @@ HB_SIZE hb_parvclen( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetCLen( pItem, ulArrayIndex ); + return hb_arrayGetCLen( pItem, nArrayIndex ); } } @@ -863,7 +863,7 @@ HB_SIZE hb_parvclen( int iParam, ... ) terminating zero byte, and it only works for parameters passed by reference. [vszakats] */ -HB_SIZE hb_parvcsiz( int iParam, ... ) +HB_SIZE hb_parvcsiz( int iParam, ... ) { HB_STACK_TLS_PRELOAD @@ -885,13 +885,13 @@ HB_SIZE hb_parvcsiz( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetCLen( pItem, ulArrayIndex ) + 1; + return hb_arrayGetCLen( pItem, nArrayIndex ) + 1; } } } @@ -920,13 +920,13 @@ const char * hb_parvds( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetDS( pItem, ulArrayIndex, hb_stackDateBuffer() ); + return hb_arrayGetDS( pItem, nArrayIndex, hb_stackDateBuffer() ); } } @@ -953,13 +953,13 @@ char * hb_parvdsbuff( char * szDate, int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetDS( pItem, ulArrayIndex, szDate ); + return hb_arrayGetDS( pItem, nArrayIndex, szDate ); } } @@ -986,13 +986,13 @@ long hb_parvdl( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetDL( pItem, ulArrayIndex ); + return hb_arrayGetDL( pItem, nArrayIndex ); } } @@ -1018,13 +1018,13 @@ double hb_parvtd( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetTD( pItem, ulArrayIndex ); + return hb_arrayGetTD( pItem, nArrayIndex ); } } @@ -1053,13 +1053,13 @@ HB_BOOL hb_parvtdt( long * plJulian, long * plMilliSec, int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetTDT( pItem, ulArrayIndex, plJulian, plMilliSec ); + return hb_arrayGetTDT( pItem, nArrayIndex, plJulian, plMilliSec ); } } @@ -1091,13 +1091,13 @@ int hb_parvl( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetL( pItem, ulArrayIndex ) ? 1 : 0; + return hb_arrayGetL( pItem, nArrayIndex ) ? 1 : 0; } } @@ -1126,13 +1126,13 @@ double hb_parvnd( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetND( pItem, ulArrayIndex ); + return hb_arrayGetND( pItem, nArrayIndex ); } } @@ -1165,13 +1165,13 @@ int hb_parvni( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetNI( pItem, ulArrayIndex ); + return hb_arrayGetNI( pItem, nArrayIndex ); } } @@ -1207,13 +1207,13 @@ long hb_parvnl( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetNL( pItem, ulArrayIndex ); + return hb_arrayGetNL( pItem, nArrayIndex ); } } @@ -1242,13 +1242,13 @@ HB_ISIZ hb_parvns( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetNS( pItem, ulArrayIndex ); + return hb_arrayGetNS( pItem, nArrayIndex ); } } @@ -1282,13 +1282,13 @@ HB_LONGLONG hb_parvnll( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetNLL( pItem, ulArrayIndex ); + return hb_arrayGetNLL( pItem, nArrayIndex ); } } @@ -1322,13 +1322,13 @@ HB_MAXINT hb_parvnint( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetNInt( pItem, ulArrayIndex ); + return hb_arrayGetNInt( pItem, nArrayIndex ); } } @@ -1353,13 +1353,13 @@ void * hb_parvptr( int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - return hb_arrayGetPtr( pItem, ulArrayIndex ); + return hb_arrayGetPtr( pItem, nArrayIndex ); } } @@ -1388,13 +1388,13 @@ void * hb_parvptrGC( const HB_GC_FUNCS * pFuncs, int iParam, ... ) else if( HB_IS_ARRAY( pItem ) ) { va_list va; - HB_SIZE ulArrayIndex; + HB_SIZE nArrayIndex; va_start( va, iParam ); - ulArrayIndex = va_arg( va, HB_SIZE ); + nArrayIndex = va_arg( va, HB_SIZE ); va_end( va ); - pItem = hb_arrayGetItemPtr( pItem, ulArrayIndex ); + pItem = hb_arrayGetItemPtr( pItem, nArrayIndex ); if( pItem && HB_IS_POINTER( pItem ) && pItem->item.asPointer.collect && hb_gcFuncs( pItem->item.asPointer.value ) == pFuncs ) @@ -1416,13 +1416,13 @@ void hb_ret( void ) } #undef hb_reta -void hb_reta( HB_SIZE ulLen ) /* undocumented hb_reta() */ +void hb_reta( HB_SIZE nLen ) /* undocumented hb_reta() */ { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_reta(%" HB_PFS "u)", ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_reta(%" HB_PFS "u)", nLen)); - hb_arrayNew( hb_stackReturnItem(), ulLen ); + hb_arrayNew( hb_stackReturnItem(), nLen ); } #undef hb_retc @@ -1466,33 +1466,33 @@ void hb_retc_const( const char * szText ) } #undef hb_retclen -void hb_retclen( const char * szText, HB_SIZE ulLen ) +void hb_retclen( const char * szText, HB_SIZE nLen ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_retclen(%.*s, %" HB_PFS "u)", ( int ) ulLen, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_retclen(%.*s, %" HB_PFS "u)", ( int ) nLen, szText, nLen)); - hb_itemPutCL( hb_stackReturnItem(), szText, ulLen ); + hb_itemPutCL( hb_stackReturnItem(), szText, nLen ); } #undef hb_retclen_buffer -void hb_retclen_buffer( char * szText, HB_SIZE ulLen ) +void hb_retclen_buffer( char * szText, HB_SIZE nLen ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_retclen_buffer(%.*s, %" HB_PFS "u)", ( int ) ulLen, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_retclen_buffer(%.*s, %" HB_PFS "u)", ( int ) nLen, szText, nLen)); - hb_itemPutCLPtr( hb_stackReturnItem(), szText, ulLen ); + hb_itemPutCLPtr( hb_stackReturnItem(), szText, nLen ); } #undef hb_retclen_const -void hb_retclen_const( const char * szText, HB_SIZE ulLen ) +void hb_retclen_const( const char * szText, HB_SIZE nLen ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_retclen_const(%.*s, %" HB_PFS "u)", ( int ) ulLen, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_retclen_const(%.*s, %" HB_PFS "u)", ( int ) nLen, szText, nLen)); - hb_itemPutCLConst( hb_stackReturnItem(), szText, ulLen ); + hb_itemPutCLConst( hb_stackReturnItem(), szText, nLen ); } /* szDate must have YYYYMMDD format */ @@ -1751,15 +1751,15 @@ int hb_storc( const char * szText, int iParam ) return 0; } -int hb_storclen( const char * szText, HB_SIZE ulLen, int iParam ) +int hb_storclen( const char * szText, HB_SIZE nLen, int iParam ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_storclen(%.*s, %" HB_PFS "u, %d)", ( int ) ulLen, szText, ulLen, iParam)); + HB_TRACE(HB_TR_DEBUG, ("hb_storclen(%.*s, %" HB_PFS "u, %d)", ( int ) nLen, szText, nLen, iParam)); if( iParam == -1 ) { - hb_itemPutCL( hb_stackReturnItem(), szText, ulLen ); + hb_itemPutCL( hb_stackReturnItem(), szText, nLen ); return 1; } else if( iParam >= 0 && iParam <= hb_pcount() ) @@ -1768,7 +1768,7 @@ int hb_storclen( const char * szText, HB_SIZE ulLen, int iParam ) if( HB_IS_BYREF( pItem ) ) { - hb_itemPutCL( hb_itemUnRef( pItem ), szText, ulLen ); + hb_itemPutCL( hb_itemUnRef( pItem ), szText, nLen ); return 1; } } @@ -1776,15 +1776,15 @@ int hb_storclen( const char * szText, HB_SIZE ulLen, int iParam ) return 0; } -int hb_storclen_buffer( char * szText, HB_SIZE ulLen, int iParam ) +int hb_storclen_buffer( char * szText, HB_SIZE nLen, int iParam ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_storclen_buffer(%.*s, %" HB_PFS "u, %d)", ( int ) ulLen, szText, ulLen, iParam)); + HB_TRACE(HB_TR_DEBUG, ("hb_storclen_buffer(%.*s, %" HB_PFS "u, %d)", ( int ) nLen, szText, nLen, iParam)); if( iParam == -1 ) { - hb_itemPutCLPtr( hb_stackReturnItem(), szText, ulLen ); + hb_itemPutCLPtr( hb_stackReturnItem(), szText, nLen ); return 1; } else if( iParam >= 0 && iParam <= hb_pcount() ) @@ -1793,7 +1793,7 @@ int hb_storclen_buffer( char * szText, HB_SIZE ulLen, int iParam ) if( HB_IS_BYREF( pItem ) ) { - hb_itemPutCLPtr( hb_itemUnRef( pItem ), szText, ulLen ); + hb_itemPutCLPtr( hb_itemUnRef( pItem ), szText, nLen ); return 1; } } @@ -2167,11 +2167,11 @@ int hb_storvc( const char * szText, int iParam, ... ) return 0; } -int hb_storvclen( const char * szText, HB_SIZE ulLen, int iParam, ... ) +int hb_storvclen( const char * szText, HB_SIZE nLen, int iParam, ... ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_storvclen(%.*s, %" HB_PFS "u, %d, ...)", ( int ) ulLen, szText, ulLen, iParam)); + HB_TRACE(HB_TR_DEBUG, ("hb_storvclen(%.*s, %" HB_PFS "u, %d, ...)", ( int ) nLen, szText, nLen, iParam)); if( iParam >= -1 && iParam <= hb_pcount() ) { @@ -2186,13 +2186,13 @@ int hb_storvclen( const char * szText, HB_SIZE ulLen, int iParam, ... ) int iRetVal; va_list va; va_start( va, iParam ); - iRetVal = hb_arraySetCL( pItem, va_arg( va, HB_SIZE ), szText, ulLen ) ? 1 : 0; + iRetVal = hb_arraySetCL( pItem, va_arg( va, HB_SIZE ), szText, nLen ) ? 1 : 0; va_end( va ); return iRetVal; } else if( bByRef || iParam == -1 ) { - hb_itemPutCL( pItem, szText, ulLen ); + hb_itemPutCL( pItem, szText, nLen ); return 1; } } @@ -2200,11 +2200,11 @@ int hb_storvclen( const char * szText, HB_SIZE ulLen, int iParam, ... ) return 0; } -int hb_storvclen_buffer( char * szText, HB_SIZE ulLen, int iParam, ... ) +int hb_storvclen_buffer( char * szText, HB_SIZE nLen, int iParam, ... ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_storvclen_buffer(%.*s, %" HB_PFS "u, %d, ...)", ( int ) ulLen, szText, ulLen, iParam)); + HB_TRACE(HB_TR_DEBUG, ("hb_storvclen_buffer(%.*s, %" HB_PFS "u, %d, ...)", ( int ) nLen, szText, nLen, iParam)); if( iParam >= -1 && iParam <= hb_pcount() ) { @@ -2219,13 +2219,13 @@ int hb_storvclen_buffer( char * szText, HB_SIZE ulLen, int iParam, ... ) int iRetVal; va_list va; va_start( va, iParam ); - iRetVal = hb_arraySetCLPtr( pItem, va_arg( va, HB_SIZE ), szText, ulLen ) ? 1 : 0; + iRetVal = hb_arraySetCLPtr( pItem, va_arg( va, HB_SIZE ), szText, nLen ) ? 1 : 0; va_end( va ); return iRetVal; } else if( bByRef || iParam == -1 ) { - hb_itemPutCLPtr( pItem, szText, ulLen ); + hb_itemPutCLPtr( pItem, szText, nLen ); return 1; } } diff --git a/harbour/src/vm/fm.c b/harbour/src/vm/fm.c index 14dadb1b03..1ddcdb511a 100644 --- a/harbour/src/vm/fm.c +++ b/harbour/src/vm/fm.c @@ -282,7 +282,7 @@ static HB_BOOL s_fInitedFM = HB_FALSE; typedef struct _HB_MEMINFO { HB_U32 u32Signature; - HB_SIZE ulSize; + HB_SIZE nSize; HB_USHORT uiProcLine; char szProcName[ HB_SYMBOL_NAME_LEN + 1 ]; struct _HB_MEMINFO * pPrevBlock; @@ -306,7 +306,7 @@ typedef struct _HB_MEMINFO #define HB_ALLOC_SIZE( n ) ( ( n ) + ( s_fStatistic ? _HB_MEMINFO_SIZE + sizeof( HB_U32 ) : HB_COUNTER_OFFSET ) ) #define HB_FM_PTR( p ) ( ( PHB_MEMINFO ) ( ( HB_BYTE * ) ( p ) - HB_MEMINFO_SIZE ) ) -#define HB_FM_BLOCKSIZE( p ) ( s_fStatistic ? HB_FM_PTR( pMem )->ulSize : 0 ) +#define HB_FM_BLOCKSIZE( p ) ( s_fStatistic ? HB_FM_PTR( pMem )->nSize : 0 ) /* NOTE: we cannot use here HB_TRACE because it will overwrite the * function name/line number of code which called hb_xalloc/hb_xgrab @@ -576,13 +576,13 @@ void hb_xsetinfo( const char * szValue ) #endif } -void * hb_xalloc( HB_SIZE ulSize ) /* allocates fixed memory, returns NULL on failure */ +void * hb_xalloc( HB_SIZE nSize ) /* allocates fixed memory, returns NULL on failure */ { PHB_MEMINFO pMem; - HB_TRACE_FM(HB_TR_DEBUG, ("hb_xalloc(%" HB_PFS "u)", ulSize)); + HB_TRACE_FM(HB_TR_DEBUG, ("hb_xalloc(%" HB_PFS "u)", nSize)); - if( ulSize == 0 ) + if( nSize == 0 ) hb_errInternal( HB_EI_XALLOCNULLSIZE, NULL, NULL, NULL ); #ifdef HB_FM_NEED_INIT @@ -590,7 +590,7 @@ void * hb_xalloc( HB_SIZE ulSize ) /* allocates fixed memory, returns NU hb_xinit(); #endif - pMem = ( PHB_MEMINFO ) malloc( HB_ALLOC_SIZE( ulSize ) ); + pMem = ( PHB_MEMINFO ) malloc( HB_ALLOC_SIZE( nSize ) ); if( ! pMem ) return pMem; @@ -617,8 +617,8 @@ void * hb_xalloc( HB_SIZE ulSize ) /* allocates fixed memory, returns NU pMem->pNextBlock = NULL; pMem->u32Signature = HB_MEMINFO_SIGNATURE; - HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize ); - pMem->ulSize = ulSize; /* size of the memory block */ + HB_FM_SETSIG( HB_MEM_PTR( pMem ), nSize ); + pMem->nSize = nSize; /* size of the memory block */ pTrace = hb_traceinfo(); if( hb_tr_level() >= HB_TR_DEBUG || pTrace->level == HB_TR_FM ) @@ -640,7 +640,7 @@ void * hb_xalloc( HB_SIZE ulSize ) /* allocates fixed memory, returns NU hb_stackBaseProcInfo( pMem->szProcName, &pMem->uiProcLine ); } - s_lMemoryConsumed += ulSize + sizeof( HB_COUNTER ); + s_lMemoryConsumed += nSize + sizeof( HB_COUNTER ); if( s_lMemoryMaxConsumed < s_lMemoryConsumed ) s_lMemoryMaxConsumed = s_lMemoryConsumed; s_lMemoryBlocks++; @@ -650,7 +650,7 @@ void * hb_xalloc( HB_SIZE ulSize ) /* allocates fixed memory, returns NU HB_FM_UNLOCK #ifdef HB_PARANOID_MEM_CHECK - memset( HB_MEM_PTR( pMem ), HB_MEMFILER, ulSize ); + memset( HB_MEM_PTR( pMem ), HB_MEMFILER, nSize ); #endif } @@ -662,13 +662,13 @@ void * hb_xalloc( HB_SIZE ulSize ) /* allocates fixed memory, returns NU return HB_MEM_PTR( pMem ); } -void * hb_xgrab( HB_SIZE ulSize ) /* allocates fixed memory, exits on failure */ +void * hb_xgrab( HB_SIZE nSize ) /* allocates fixed memory, exits on failure */ { PHB_MEMINFO pMem; - HB_TRACE_FM(HB_TR_DEBUG, ("hb_xgrab(%" HB_PFS "u)", ulSize)); + HB_TRACE_FM(HB_TR_DEBUG, ("hb_xgrab(%" HB_PFS "u)", nSize)); - if( ulSize == 0 ) + if( nSize == 0 ) hb_errInternal( HB_EI_XGRABNULLSIZE, NULL, NULL, NULL ); #ifdef HB_FM_NEED_INIT @@ -676,7 +676,7 @@ void * hb_xgrab( HB_SIZE ulSize ) /* allocates fixed memory, exits on fa hb_xinit(); #endif - pMem = ( PHB_MEMINFO ) malloc( HB_ALLOC_SIZE( ulSize ) ); + pMem = ( PHB_MEMINFO ) malloc( HB_ALLOC_SIZE( nSize ) ); if( ! pMem ) hb_errInternal( HB_EI_XGRABALLOC, NULL, NULL, NULL ); @@ -703,8 +703,8 @@ void * hb_xgrab( HB_SIZE ulSize ) /* allocates fixed memory, exits on fa pMem->pNextBlock = NULL; pMem->u32Signature = HB_MEMINFO_SIGNATURE; - HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize ); - pMem->ulSize = ulSize; /* size of the memory block */ + HB_FM_SETSIG( HB_MEM_PTR( pMem ), nSize ); + pMem->nSize = nSize; /* size of the memory block */ pTrace = hb_traceinfo(); if( hb_tr_level() >= HB_TR_DEBUG || pTrace->level == HB_TR_FM ) @@ -726,7 +726,7 @@ void * hb_xgrab( HB_SIZE ulSize ) /* allocates fixed memory, exits on fa hb_stackBaseProcInfo( pMem->szProcName, &pMem->uiProcLine ); } - s_lMemoryConsumed += ulSize + sizeof( HB_COUNTER ); + s_lMemoryConsumed += nSize + sizeof( HB_COUNTER ); if( s_lMemoryMaxConsumed < s_lMemoryConsumed ) s_lMemoryMaxConsumed = s_lMemoryConsumed; s_lMemoryBlocks++; @@ -736,7 +736,7 @@ void * hb_xgrab( HB_SIZE ulSize ) /* allocates fixed memory, exits on fa HB_FM_UNLOCK #ifdef HB_PARANOID_MEM_CHECK - memset( HB_MEM_PTR( pMem ), HB_MEMFILER, ulSize ); + memset( HB_MEM_PTR( pMem ), HB_MEMFILER, nSize ); #endif } @@ -748,27 +748,27 @@ void * hb_xgrab( HB_SIZE ulSize ) /* allocates fixed memory, exits on fa return HB_MEM_PTR( pMem ); } -void * hb_xrealloc( void * pMem, HB_SIZE ulSize ) /* reallocates memory */ +void * hb_xrealloc( void * pMem, HB_SIZE nSize ) /* reallocates memory */ { - HB_TRACE_FM(HB_TR_DEBUG, ("hb_xrealloc(%p, %" HB_PFS "u)", pMem, ulSize)); + HB_TRACE_FM(HB_TR_DEBUG, ("hb_xrealloc(%p, %" HB_PFS "u)", pMem, nSize)); #if 0 /* disabled to make hb_xrealloc() ANSI-C realloc() compatible */ if( ! pMem ) hb_errInternal( HB_EI_XREALLOCNULL, NULL, NULL, NULL ); - if( ulSize == 0 ) + if( nSize == 0 ) hb_errInternal( HB_EI_XREALLOCNULLSIZE, NULL, NULL, NULL ); #endif #ifdef HB_FM_STATISTICS if( pMem == NULL ) { - if( ulSize == 0 ) + if( nSize == 0 ) hb_errInternal( HB_EI_XREALLOCNULLSIZE, NULL, NULL, NULL ); - return hb_xgrab( ulSize ); + return hb_xgrab( nSize ); } - else if( ulSize == 0 ) + else if( nSize == 0 ) { hb_xfree( pMem ); return NULL; @@ -776,49 +776,49 @@ void * hb_xrealloc( void * pMem, HB_SIZE ulSize ) /* reallocates memory */ else if( s_fStatistic ) { PHB_MEMINFO pMemBlock; - HB_SIZE ulMemSize; + HB_SIZE nMemSize; pMemBlock = HB_FM_PTR( pMem ); if( pMemBlock->u32Signature != HB_MEMINFO_SIGNATURE ) hb_errInternal( HB_EI_XREALLOCINV, NULL, NULL, NULL ); - ulMemSize = pMemBlock->ulSize; + nMemSize = pMemBlock->nSize; - if( HB_FM_GETSIG( pMem, ulMemSize ) != HB_MEMINFO_SIGNATURE ) + if( HB_FM_GETSIG( pMem, nMemSize ) != HB_MEMINFO_SIGNATURE ) hb_errInternal( HB_EI_XMEMOVERFLOW, NULL, NULL, NULL ); - HB_FM_CLRSIG( pMem, ulMemSize ); + HB_FM_CLRSIG( pMem, nMemSize ); HB_FM_LOCK #ifdef HB_PARANOID_MEM_CHECK - pMem = malloc( HB_ALLOC_SIZE( ulSize ) ); + pMem = malloc( HB_ALLOC_SIZE( nSize ) ); if( pMem ) { HB_ATOM_SET( HB_COUNTER_PTR( HB_MEM_PTR( pMem ) ), 1 ); - if( ulSize > ulMemSize ) + if( nSize > nMemSize ) { - memcpy( pMem, pMemBlock, HB_ALLOC_SIZE( ulMemSize ) ); - memset( ( HB_BYTE * ) pMem + HB_ALLOC_SIZE( ulMemSize ), HB_MEMFILER, ulSize - ulMemSize ); + memcpy( pMem, pMemBlock, HB_ALLOC_SIZE( nMemSize ) ); + memset( ( HB_BYTE * ) pMem + HB_ALLOC_SIZE( nMemSize ), HB_MEMFILER, nSize - nMemSize ); } else - memcpy( pMem, pMemBlock, HB_ALLOC_SIZE( ulSize ) ); + memcpy( pMem, pMemBlock, HB_ALLOC_SIZE( nSize ) ); } - memset( pMemBlock, HB_MEMFILER, HB_ALLOC_SIZE( ulMemSize ) ); + memset( pMemBlock, HB_MEMFILER, HB_ALLOC_SIZE( nMemSize ) ); free( pMemBlock ); #else - pMem = realloc( pMemBlock, HB_ALLOC_SIZE( ulSize ) ); + pMem = realloc( pMemBlock, HB_ALLOC_SIZE( nSize ) ); #endif - s_lMemoryConsumed += ( ulSize - ulMemSize ); + s_lMemoryConsumed += ( nSize - nMemSize ); if( s_lMemoryMaxConsumed < s_lMemoryConsumed ) s_lMemoryMaxConsumed = s_lMemoryConsumed; if( pMem ) { - ( ( PHB_MEMINFO ) pMem )->ulSize = ulSize; /* size of the memory block */ - HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize ); + ( ( PHB_MEMINFO ) pMem )->nSize = nSize; /* size of the memory block */ + HB_FM_SETSIG( HB_MEM_PTR( pMem ), nSize ); if( ( ( PHB_MEMINFO ) pMem )->pPrevBlock ) ( ( PHB_MEMINFO ) pMem )->pPrevBlock->pNextBlock = ( PHB_MEMINFO ) pMem; if( ( ( PHB_MEMINFO ) pMem )->pNextBlock ) @@ -833,7 +833,7 @@ void * hb_xrealloc( void * pMem, HB_SIZE ulSize ) /* reallocates memory */ HB_FM_UNLOCK } else - pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE( ulSize ) ); + pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE( nSize ) ); if( ! pMem ) hb_errInternal( HB_EI_XREALLOC, NULL, NULL, NULL ); @@ -842,20 +842,20 @@ void * hb_xrealloc( void * pMem, HB_SIZE ulSize ) /* reallocates memory */ if( pMem == NULL ) { - if( ulSize == 0 ) + if( nSize == 0 ) hb_errInternal( HB_EI_XREALLOCNULLSIZE, NULL, NULL, NULL ); - pMem = malloc( HB_ALLOC_SIZE( ulSize ) ); + pMem = malloc( HB_ALLOC_SIZE( nSize ) ); if( pMem ) HB_ATOM_SET( HB_COUNTER_PTR( HB_MEM_PTR( pMem ) ), 1 ); } - else if( ulSize == 0 ) + else if( nSize == 0 ) { free( HB_FM_PTR( pMem ) ); return NULL; } else { - pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE( ulSize ) ); + pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE( nSize ) ); } if( !pMem ) @@ -881,12 +881,12 @@ void hb_xfree( void * pMem ) /* frees fixed memory */ if( pMemBlock->u32Signature != HB_MEMINFO_SIGNATURE ) hb_errInternal( HB_EI_XFREEINV, NULL, NULL, NULL ); - if( HB_FM_GETSIG( pMem, pMemBlock->ulSize ) != HB_MEMINFO_SIGNATURE ) + if( HB_FM_GETSIG( pMem, pMemBlock->nSize ) != HB_MEMINFO_SIGNATURE ) hb_errInternal( HB_EI_XMEMOVERFLOW, NULL, NULL, NULL ); HB_FM_LOCK - s_lMemoryConsumed -= pMemBlock->ulSize + sizeof( HB_COUNTER ); + s_lMemoryConsumed -= pMemBlock->nSize + sizeof( HB_COUNTER ); s_lMemoryBlocks--; if( pMemBlock->pPrevBlock ) @@ -902,9 +902,9 @@ void hb_xfree( void * pMem ) /* frees fixed memory */ HB_FM_UNLOCK pMemBlock->u32Signature = 0; - HB_FM_CLRSIG( pMem, pMemBlock->ulSize ); + HB_FM_CLRSIG( pMem, pMemBlock->nSize ); #ifdef HB_PARANOID_MEM_CHECK - memset( pMemBlock, HB_MEMFILER, HB_ALLOC_SIZE( pMemBlock->ulSize ) ); + memset( pMemBlock, HB_MEMFILER, HB_ALLOC_SIZE( pMemBlock->nSize ) ); #endif } @@ -963,48 +963,48 @@ HB_COUNTER hb_xRefCount( void * pMem ) /* reallocates memory, create copy if reference counter greater then 1 */ #undef hb_xRefResize -void * hb_xRefResize( void * pMem, HB_SIZE ulSave, HB_SIZE ulSize, HB_SIZE * pulAllocated ) +void * hb_xRefResize( void * pMem, HB_SIZE nSave, HB_SIZE nSize, HB_SIZE * pnAllocated ) { #ifdef HB_FM_STATISTICS if( HB_ATOM_GET( HB_COUNTER_PTR( pMem ) ) > 1 ) { - void * pMemNew = memcpy( hb_xgrab( ulSize ), pMem, HB_MIN( ulSave, ulSize ) ); + void * pMemNew = memcpy( hb_xgrab( nSize ), pMem, HB_MIN( nSave, nSize ) ); if( HB_ATOM_DEC( HB_COUNTER_PTR( pMem ) ) == 0 ) hb_xfree( pMem ); - *pulAllocated = ulSize; + *pnAllocated = nSize; return pMemNew; } - else if( ulSize <= *pulAllocated ) + else if( nSize <= *pnAllocated ) return pMem; - *pulAllocated = ulSize; - return hb_xrealloc( pMem, ulSize ); + *pnAllocated = nSize; + return hb_xrealloc( pMem, nSize ); #else if( HB_ATOM_GET( HB_COUNTER_PTR( pMem ) ) > 1 ) { - void * pMemNew = malloc( HB_ALLOC_SIZE( ulSize ) ); + void * pMemNew = malloc( HB_ALLOC_SIZE( nSize ) ); if( pMemNew ) { HB_ATOM_SET( HB_COUNTER_PTR( HB_MEM_PTR( pMemNew ) ), 1 ); - memcpy( HB_MEM_PTR( pMemNew ), pMem, HB_MIN( ulSave, ulSize ) ); + memcpy( HB_MEM_PTR( pMemNew ), pMem, HB_MIN( nSave, nSize ) ); if( HB_ATOM_DEC( HB_COUNTER_PTR( pMem ) ) == 0 ) free( HB_FM_PTR( pMem ) ); - *pulAllocated = ulSize; + *pnAllocated = nSize; return HB_MEM_PTR( pMemNew ); } } - else if( ulSize <= *pulAllocated ) + else if( nSize <= *pnAllocated ) return pMem; else { - *pulAllocated = ulSize; - pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE( ulSize ) ); + *pnAllocated = nSize; + pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE( nSize ) ); if( pMem ) return HB_MEM_PTR( pMem ); } @@ -1067,40 +1067,40 @@ void hb_xinit( void ) /* Initialize fixed memory subsystem */ of pMem memory block */ #ifdef HB_FM_STATISTICS -static char * hb_mem2str( char * membuffer, void * pMem, HB_SIZE uiSize ) +static char * hb_mem2str( char * membuffer, void * pMem, HB_SIZE nSize ) { HB_BYTE * cMem = ( HB_BYTE * ) pMem; - HB_SIZE uiIndex, uiPrintable; + HB_SIZE nIndex, nPrintable; - uiPrintable = 0; - for( uiIndex = 0; uiIndex < uiSize; uiIndex++ ) - if( ( cMem[ uiIndex ] & 0x60 ) != 0 ) - uiPrintable++; + nPrintable = 0; + for( nIndex = 0; nIndex < nSize; nIndex++ ) + if( ( cMem[ nIndex ] & 0x60 ) != 0 ) + nPrintable++; - if( uiPrintable * 100 / uiSize > 70 ) /* more then 70% printable chars */ + if( nPrintable * 100 / nSize > 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 ]; + for( nIndex = 0; nIndex < nSize; nIndex++ ) + if( cMem[ nIndex ] >= ' ' ) + membuffer[ nIndex ] = cMem[ nIndex ]; else - membuffer[ uiIndex ] = '.'; - membuffer[ uiIndex ] = '\0'; + membuffer[ nIndex ] = '.'; + membuffer[ nIndex ] = '\0'; } else { /* format as hex */ - for( uiIndex = 0; uiIndex < uiSize; uiIndex++ ) + for( nIndex = 0; nIndex < nSize; nIndex++ ) { int lownibble, hinibble; - hinibble = cMem[ uiIndex ] >> 4; - lownibble = cMem[ uiIndex ] & 0x0F; - membuffer[ uiIndex * 2 ] = hinibble <= 9 ? + hinibble = cMem[ nIndex ] >> 4; + lownibble = cMem[ nIndex ] & 0x0F; + membuffer[ nIndex * 2 ] = hinibble <= 9 ? ( '0' + hinibble ) : ( 'A' + hinibble - 10 ); - membuffer[ uiIndex * 2 + 1 ] = lownibble <= 9 ? + membuffer[ nIndex * 2 + 1 ] = lownibble <= 9 ? ( '0' + lownibble ) : ( 'A' + lownibble - 10 ); } - membuffer[ uiIndex * 2 ] = '\0'; + membuffer[ nIndex * 2 ] = '\0'; } return membuffer; @@ -1163,17 +1163,17 @@ void hb_xexit( void ) /* Deinitialize fixed memory subsystem */ 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, + pMemBlock->nSize, pMemBlock->szProcName, pMemBlock->uiProcLine, hb_mem2str( membuffer, ( char * ) HB_MEM_PTR( pMemBlock ), - HB_MIN( pMemBlock->ulSize, HB_MAX_MEM2STR_BLOCK ) ) ) ); + HB_MIN( pMemBlock->nSize, HB_MAX_MEM2STR_BLOCK ) ) ) ); if( hLog ) { fprintf( hLog, HB_I_("Block %i %p (size %lu) %s(%i), \"%s\"\n"), ui, ( char * ) HB_MEM_PTR( pMemBlock ), - pMemBlock->ulSize, pMemBlock->szProcName, pMemBlock->uiProcLine, + pMemBlock->nSize, pMemBlock->szProcName, pMemBlock->uiProcLine, hb_mem2str( membuffer, ( char * ) HB_MEM_PTR( pMemBlock ), - HB_MIN( pMemBlock->ulSize, HB_MAX_MEM2STR_BLOCK ) ) ); + HB_MIN( pMemBlock->nSize, HB_MAX_MEM2STR_BLOCK ) ) ); } } @@ -1216,7 +1216,7 @@ void hb_xexit( void ) /* Deinitialize fixed memory subsystem */ HB_SIZE hb_xquery( int iMode ) { - HB_SIZE ulResult; + HB_SIZE nResult; HB_TRACE(HB_TR_DEBUG, ("hb_xquery(%d)", iMode)); @@ -1229,19 +1229,19 @@ HB_SIZE hb_xquery( int iMode ) { MEMORYSTATUS memorystatus; GlobalMemoryStatus( &memorystatus ); - ulResult = memorystatus.dwAvailPhys / 1024; + nResult = memorystatus.dwAvailPhys / 1024; } #elif defined( HB_OS_OS2 ) { ULONG ulSysInfo = 0; if( DosQuerySysInfo( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR ) - ulResult = 0; + nResult = 0; else - ulResult = ulSysInfo / 1024; + nResult = ulSysInfo / 1024; } #else - ulResult = 9999; + nResult = 9999; #endif break; @@ -1250,19 +1250,19 @@ HB_SIZE hb_xquery( int iMode ) { MEMORYSTATUS memorystatus; GlobalMemoryStatus( &memorystatus ); - ulResult = HB_MIN( memorystatus.dwAvailPhys, ULONG_MAX ) / 1024; + nResult = 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; + nResult = 0; else - ulResult = HB_MIN( ulSysInfo, ULONG_MAX ) / 1024; + nResult = HB_MIN( ulSysInfo, ULONG_MAX ) / 1024; } #else - ulResult = 9999; + nResult = 9999; #endif break; @@ -1271,19 +1271,19 @@ HB_SIZE hb_xquery( int iMode ) { MEMORYSTATUS memorystatus; GlobalMemoryStatus( &memorystatus ); - ulResult = memorystatus.dwAvailPhys / 1024; + nResult = memorystatus.dwAvailPhys / 1024; } #elif defined( HB_OS_OS2 ) { ULONG ulSysInfo = 0; if( DosQuerySysInfo( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR ) - ulResult = 0; + nResult = 0; else - ulResult = ulSysInfo / 1024; + nResult = ulSysInfo / 1024; } #else - ulResult = 9999; + nResult = 9999; #endif break; @@ -1292,27 +1292,27 @@ HB_SIZE hb_xquery( int iMode ) { MEMORYSTATUS memorystatus; GlobalMemoryStatus( &memorystatus ); - ulResult = memorystatus.dwAvailVirtual / 1024; + nResult = memorystatus.dwAvailVirtual / 1024; } #elif defined( HB_OS_OS2 ) { ULONG ulSysInfo = 0; if( DosQuerySysInfo( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR ) - ulResult = 0; + nResult = 0; else - ulResult = ulSysInfo / 1024; + nResult = ulSysInfo / 1024; } #else - ulResult = 9999; + nResult = 9999; #endif break; case HB_MEM_EMS: /* UNDOCUMENTED! (Free Expanded Memory [KB]) (?) */ #if defined( HB_OS_WIN ) || defined( HB_OS_OS2 ) - ulResult = 0; + nResult = 0; #else - ulResult = 9999; + nResult = 9999; #endif break; @@ -1321,27 +1321,27 @@ HB_SIZE hb_xquery( int iMode ) { MEMORYSTATUS memorystatus; GlobalMemoryStatus( &memorystatus ); - ulResult = memorystatus.dwTotalPhys / 1024; + nResult = memorystatus.dwTotalPhys / 1024; } #elif defined( HB_OS_OS2 ) { ULONG ulSysInfo = 0; if( DosQuerySysInfo( QSV_MAXPRMEM, QSV_MAXPRMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR ) - ulResult = 0; + nResult = 0; else - ulResult = ulSysInfo / 1024; + nResult = ulSysInfo / 1024; } #else - ulResult = 9999; + nResult = 9999; #endif break; case HB_MEM_FMSEGS: /* UNDOCUMENTED! (Segments in Fixed Memory/Heap) (?) */ #if defined( HB_OS_WIN ) || defined( HB_OS_OS2 ) - ulResult = 1; + nResult = 1; #else - ulResult = 9999; + nResult = 9999; #endif break; @@ -1350,75 +1350,75 @@ HB_SIZE hb_xquery( int iMode ) { MEMORYSTATUS memorystatus; GlobalMemoryStatus( &memorystatus ); - ulResult = memorystatus.dwAvailPageFile / 1024; + nResult = 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; + nResult = 9999; } #else - ulResult = 9999; + nResult = 9999; #endif break; case HB_MEM_CONV: /* UNDOCUMENTED! (Free Conventional [KB]) */ #if defined( HB_OS_WIN ) || defined( HB_OS_OS2 ) - ulResult = 0; + nResult = 0; #else - ulResult = 9999; + nResult = 9999; #endif break; case HB_MEM_EMSUSED: /* UNDOCUMENTED! (Used Expanded Memory [KB]) (?) */ - ulResult = 0; + nResult = 0; break; case HB_MEM_USED: /* Harbour extension (Memory used [bytes]) */ #ifdef HB_FM_STATISTICS - ulResult = s_lMemoryConsumed; + nResult = s_lMemoryConsumed; #else - ulResult = 0; + nResult = 0; #endif break; case HB_MEM_BLOCKS: /* Harbour extension (Memory blocks used) */ #ifdef HB_FM_STATISTICS - ulResult = s_lMemoryBlocks; + nResult = s_lMemoryBlocks; #else - ulResult = 0; + nResult = 0; #endif break; case HB_MEM_USEDMAX: /* Harbour extension (Maximum memory used [bytes]) */ #ifdef HB_FM_STATISTICS - ulResult = s_lMemoryMaxConsumed; + nResult = s_lMemoryMaxConsumed; #else - ulResult = 0; + nResult = 0; #endif break; case HB_MEM_STACKITEMS: /* Harbour extension (Total items allocated for the stack) */ - ulResult = hb_stackTotalItems(); + nResult = hb_stackTotalItems(); break; case HB_MEM_STACK: /* Harbour extension (Total memory size used by the stack [bytes]) */ - ulResult = hb_stackTotalItems() * sizeof( HB_ITEM ); + nResult = hb_stackTotalItems() * sizeof( HB_ITEM ); break; case HB_MEM_STACK_TOP : /* Harbour extension (Total items currently on the stack) */ { HB_STACK_TLS_PRELOAD - ulResult = hb_stackTopOffset( ); + nResult = hb_stackTopOffset( ); break; } default: - ulResult = 0; + nResult = 0; } - return ulResult; + return nResult; } HB_BOOL hb_xtraced( void ) diff --git a/harbour/src/vm/garbage.c b/harbour/src/vm/garbage.c index 9e529bf2f5..988acce437 100644 --- a/harbour/src/vm/garbage.c +++ b/harbour/src/vm/garbage.c @@ -121,7 +121,7 @@ typedef struct HB_GARBAGE_ #define HB_BLOCK_PTR( p ) ( ( void * ) ( ( HB_BYTE * ) ( p ) + HB_GARBAGE_SIZE ) ) /* we may use a cache later */ -#define HB_GARBAGE_NEW( ulSize ) ( ( HB_GARBAGE_PTR ) hb_xgrab( HB_GARBAGE_SIZE + ( ulSize ) ) ) +#define HB_GARBAGE_NEW( nSize ) ( ( HB_GARBAGE_PTR ) hb_xgrab( HB_GARBAGE_SIZE + ( nSize ) ) ) #define HB_GARBAGE_FREE( pAlloc ) hb_xfree( ( void * ) ( pAlloc ) ) /* status of memory block */ @@ -196,11 +196,11 @@ static void hb_gcUnlink( HB_GARBAGE_PTR *pList, HB_GARBAGE_PTR pAlloc ) } /* allocates a memory block */ -void * hb_gcAllocate( HB_SIZE ulSize, const HB_GC_FUNCS * pFuncs ) +void * hb_gcAllocate( HB_SIZE nSize, const HB_GC_FUNCS * pFuncs ) { HB_GARBAGE_PTR pAlloc; - pAlloc = HB_GARBAGE_NEW( ulSize ); + pAlloc = HB_GARBAGE_NEW( nSize ); pAlloc->pFuncs = pFuncs; pAlloc->locked = 1; pAlloc->used = s_uUsedFlag; @@ -212,11 +212,11 @@ void * hb_gcAllocate( HB_SIZE ulSize, const HB_GC_FUNCS * pFuncs ) } /* allocates a memory block */ -void * hb_gcAllocRaw( HB_SIZE ulSize, const HB_GC_FUNCS * pFuncs ) +void * hb_gcAllocRaw( HB_SIZE nSize, const HB_GC_FUNCS * pFuncs ) { HB_GARBAGE_PTR pAlloc; - pAlloc = HB_GARBAGE_NEW( ulSize ); + pAlloc = HB_GARBAGE_NEW( nSize ); pAlloc->pFuncs = pFuncs; pAlloc->locked = 0; pAlloc->used = s_uUsedFlag; diff --git a/harbour/src/vm/hashes.c b/harbour/src/vm/hashes.c index bb317b3518..915b5c12aa 100644 --- a/harbour/src/vm/hashes.c +++ b/harbour/src/vm/hashes.c @@ -76,9 +76,9 @@ typedef struct _HB_BASEHASH { PHB_HASHPAIR pPairs; /* pointer to the array of key/value pairs */ PHB_ITEM pDefault; /* default autoadd value */ - HB_SIZE * pulPos; /* the sort order for HB_HASH_KEEPORDER */ - HB_SIZE ulSize; /* size of allocated pair array */ - HB_SIZE ulLen; /* number of used items in pair array */ + HB_SIZE * pnPos; /* the sort order for HB_HASH_KEEPORDER */ + HB_SIZE nSize; /* size of allocated pair array */ + HB_SIZE nLen; /* number of used items in pair array */ int iFlags; /* hash item flags */ } HB_BASEHASH, * PHB_BASEHASH, * HB_BASEHASH_PTR; @@ -90,10 +90,10 @@ static HB_GARBAGE_FUNC( hb_hashGarbageRelease ) HB_TRACE(HB_TR_INFO, ("hb_hashGarbageRelease(%p)", pBaseHash )); - if( pBaseHash->ulSize > 0 ) + if( pBaseHash->nSize > 0 ) { PHB_HASHPAIR pPairs = pBaseHash->pPairs; - HB_SIZE ulLen = pBaseHash->ulLen; + HB_SIZE nLen = pBaseHash->nLen; /* * clear the pBaseHash->pPairs to avoid infinite loop in cross @@ -101,20 +101,20 @@ static HB_GARBAGE_FUNC( hb_hashGarbageRelease ) * object destructor [druzus] */ pBaseHash->pPairs = NULL; - pBaseHash->ulLen = 0; + pBaseHash->nLen = 0; - if( pBaseHash->pulPos ) + if( pBaseHash->pnPos ) { - hb_xfree( pBaseHash->pulPos ); - pBaseHash->pulPos = NULL; + hb_xfree( pBaseHash->pnPos ); + pBaseHash->pnPos = NULL; } - while( ulLen-- ) + while( nLen-- ) { - if( HB_IS_COMPLEX( &pPairs[ ulLen ].key ) ) - hb_itemClear( &pPairs[ ulLen ].key ); - if( HB_IS_COMPLEX( &pPairs[ ulLen ].value ) ) - hb_itemClear( &pPairs[ ulLen ].value ); + if( HB_IS_COMPLEX( &pPairs[ nLen ].key ) ) + hb_itemClear( &pPairs[ nLen ].key ); + if( HB_IS_COMPLEX( &pPairs[ nLen ].value ) ) + hb_itemClear( &pPairs[ nLen ].value ); } hb_xfree( pPairs ); } @@ -132,17 +132,17 @@ static HB_GARBAGE_FUNC( hb_hashGarbageMark ) HB_TRACE(HB_TR_INFO, ("hb_hashMarkGarbage(%p)", pBaseHash )); - if( pBaseHash->ulLen > 0 ) + if( pBaseHash->nLen > 0 ) { PHB_HASHPAIR pPairs = pBaseHash->pPairs; - HB_SIZE ulLen = pBaseHash->ulLen; + HB_SIZE nLen = pBaseHash->nLen; - while( ulLen-- ) + while( nLen-- ) { - if( HB_IS_GCITEM( &pPairs[ ulLen ].key ) ) - hb_gcItemRef( &pPairs[ ulLen ].key ); - if( HB_IS_GCITEM( &pPairs[ ulLen ].value ) ) - hb_gcItemRef( &pPairs[ ulLen ].value ); + if( HB_IS_GCITEM( &pPairs[ nLen ].key ) ) + hb_gcItemRef( &pPairs[ nLen ].key ); + if( HB_IS_GCITEM( &pPairs[ nLen ].value ) ) + hb_gcItemRef( &pPairs[ nLen ].value ); } } if( pBaseHash->pDefault ) @@ -213,43 +213,43 @@ static int hb_hashItemCmp( PHB_ITEM pKey1, PHB_ITEM pKey2, int iFlags ) static void hb_hashResort( PHB_BASEHASH pBaseHash ) { - HB_SIZE ulPos, ulFrom; + HB_SIZE nPos, nFrom; int iFlags = pBaseHash->iFlags; /* The hash array is probably quite well sorted so this trivial * algorithm is the most efficient one [druzus] */ - if( pBaseHash->pulPos ) + if( pBaseHash->pnPos ) { - for( ulFrom = 1; ulFrom < pBaseHash->ulLen; ++ulFrom ) + for( nFrom = 1; nFrom < pBaseHash->nLen; ++nFrom ) { - ulPos = ulFrom; - while( ulPos > 0 && hb_hashItemCmp( &pBaseHash->pPairs[ pBaseHash->pulPos[ ulPos - 1 ] ].key, - &pBaseHash->pPairs[ pBaseHash->pulPos[ ulPos ] ].key, - iFlags ) > 0 ) + nPos = nFrom; + while( nPos > 0 && hb_hashItemCmp( &pBaseHash->pPairs[ pBaseHash->pnPos[ nPos - 1 ] ].key, + &pBaseHash->pPairs[ pBaseHash->pnPos[ nPos ] ].key, + iFlags ) > 0 ) { - HB_SIZE ulTemp = pBaseHash->pulPos[ ulPos - 1 ]; - pBaseHash->pulPos[ ulPos - 1 ] = pBaseHash->pulPos[ ulPos ]; - pBaseHash->pulPos[ ulPos ] = ulTemp; - --ulPos; + HB_SIZE nTemp = pBaseHash->pnPos[ nPos - 1 ]; + pBaseHash->pnPos[ nPos - 1 ] = pBaseHash->pnPos[ nPos ]; + pBaseHash->pnPos[ nPos ] = nTemp; + --nPos; } } } else { - for( ulFrom = 1; ulFrom < pBaseHash->ulLen; ++ulFrom ) + for( nFrom = 1; nFrom < pBaseHash->nLen; ++nFrom ) { - ulPos = ulFrom; - while( ulPos > 0 && hb_hashItemCmp( &pBaseHash->pPairs[ ulPos - 1 ].key, - &pBaseHash->pPairs[ ulPos ].key, - iFlags ) > 0 ) + nPos = nFrom; + while( nPos > 0 && hb_hashItemCmp( &pBaseHash->pPairs[ nPos - 1 ].key, + &pBaseHash->pPairs[ nPos ].key, + iFlags ) > 0 ) { HB_HASHPAIR pair; - memcpy( &pair, pBaseHash->pPairs + ulPos - 1, sizeof( HB_HASHPAIR ) ); - memcpy( pBaseHash->pPairs + ulPos - 1, pBaseHash->pPairs + ulPos, sizeof( HB_HASHPAIR ) ); - memcpy( pBaseHash->pPairs + ulPos, &pair, sizeof( HB_HASHPAIR ) ); - --ulPos; + memcpy( &pair, pBaseHash->pPairs + nPos - 1, sizeof( HB_HASHPAIR ) ); + memcpy( pBaseHash->pPairs + nPos - 1, pBaseHash->pPairs + nPos, sizeof( HB_HASHPAIR ) ); + memcpy( pBaseHash->pPairs + nPos, &pair, sizeof( HB_HASHPAIR ) ); + --nPos; } } } @@ -257,86 +257,86 @@ static void hb_hashResort( PHB_BASEHASH pBaseHash ) pBaseHash->iFlags &= ~HB_HASH_RESORT; } -static HB_BOOL hb_hashFind( PHB_BASEHASH pBaseHash, PHB_ITEM pKey, HB_SIZE * pulPos ) +static HB_BOOL hb_hashFind( PHB_BASEHASH pBaseHash, PHB_ITEM pKey, HB_SIZE * pnPos ) { - HB_SIZE ulLeft, ulRight, ulMiddle; + HB_SIZE nLeft, nRight, nMiddle; int iFlags = pBaseHash->iFlags; int i; if( iFlags & HB_HASH_RESORT ) hb_hashResort( pBaseHash ); - ulLeft = 0; - ulRight = pBaseHash->ulLen; + nLeft = 0; + nRight = pBaseHash->nLen; - while( ulLeft < ulRight ) + while( nLeft < nRight ) { - ulMiddle = ( ulLeft + ulRight ) >> 1; - i = hb_hashItemCmp( &pBaseHash->pPairs[ pBaseHash->pulPos ? - pBaseHash->pulPos[ ulMiddle ] : ulMiddle ].key, + nMiddle = ( nLeft + nRight ) >> 1; + i = hb_hashItemCmp( &pBaseHash->pPairs[ pBaseHash->pnPos ? + pBaseHash->pnPos[ nMiddle ] : nMiddle ].key, pKey, iFlags ); if( i == 0 ) { - if( pulPos ) - *pulPos = pBaseHash->pulPos ? pBaseHash->pulPos[ ulMiddle ] : ulMiddle; + if( pnPos ) + *pnPos = pBaseHash->pnPos ? pBaseHash->pnPos[ nMiddle ] : nMiddle; return HB_TRUE; } else if( i < 0 ) - ulLeft = ulMiddle + 1; + nLeft = nMiddle + 1; else - ulRight = ulMiddle; + nRight = nMiddle; } - if( pulPos ) - *pulPos = ulLeft; + if( pnPos ) + *pnPos = nLeft; return HB_FALSE; } -static void hb_hashResize( PHB_BASEHASH pBaseHash, HB_SIZE ulNewSize ) +static void hb_hashResize( PHB_BASEHASH pBaseHash, HB_SIZE nNewSize ) { - if( pBaseHash->ulSize < ulNewSize ) + if( pBaseHash->nSize < nNewSize ) { - if( pBaseHash->ulSize ) + if( pBaseHash->nSize ) { pBaseHash->pPairs = ( PHB_HASHPAIR ) hb_xrealloc( pBaseHash->pPairs, - ulNewSize * sizeof( HB_HASHPAIR ) ); - if( pBaseHash->pulPos ) - pBaseHash->pulPos = ( HB_SIZE * ) hb_xrealloc( pBaseHash->pulPos, - ulNewSize * sizeof( HB_SIZE ) ); + nNewSize * sizeof( HB_HASHPAIR ) ); + if( pBaseHash->pnPos ) + pBaseHash->pnPos = ( HB_SIZE * ) hb_xrealloc( pBaseHash->pnPos, + nNewSize * sizeof( HB_SIZE ) ); } else { - pBaseHash->pPairs = ( PHB_HASHPAIR ) hb_xgrab( ulNewSize * sizeof( HB_HASHPAIR ) ); + pBaseHash->pPairs = ( PHB_HASHPAIR ) hb_xgrab( nNewSize * sizeof( HB_HASHPAIR ) ); if( pBaseHash->iFlags & HB_HASH_KEEPORDER ) - pBaseHash->pulPos = ( HB_SIZE * ) hb_xgrab( ulNewSize * sizeof( HB_SIZE ) ); + pBaseHash->pnPos = ( HB_SIZE * ) hb_xgrab( nNewSize * sizeof( HB_SIZE ) ); } do { - pBaseHash->pPairs[ pBaseHash->ulSize ].key.type = HB_IT_NIL; - pBaseHash->pPairs[ pBaseHash->ulSize ].value.type = HB_IT_NIL; + pBaseHash->pPairs[ pBaseHash->nSize ].key.type = HB_IT_NIL; + pBaseHash->pPairs[ pBaseHash->nSize ].value.type = HB_IT_NIL; } - while( ++pBaseHash->ulSize < ulNewSize ); + while( ++pBaseHash->nSize < nNewSize ); } - else if( pBaseHash->ulSize > ulNewSize && pBaseHash->ulLen <= ulNewSize ) + else if( pBaseHash->nSize > nNewSize && pBaseHash->nLen <= nNewSize ) { - pBaseHash->ulSize = ulNewSize; - if( ulNewSize ) + pBaseHash->nSize = nNewSize; + if( nNewSize ) { pBaseHash->pPairs = ( PHB_HASHPAIR ) hb_xrealloc( pBaseHash->pPairs, - ulNewSize * sizeof( HB_HASHPAIR ) ); - if( pBaseHash->pulPos ) - pBaseHash->pulPos = ( HB_SIZE * ) hb_xrealloc( pBaseHash->pulPos, - ulNewSize * sizeof( HB_SIZE ) ); + nNewSize * sizeof( HB_HASHPAIR ) ); + if( pBaseHash->pnPos ) + pBaseHash->pnPos = ( HB_SIZE * ) hb_xrealloc( pBaseHash->pnPos, + nNewSize * sizeof( HB_SIZE ) ); } else { hb_xfree( pBaseHash->pPairs ); pBaseHash->pPairs = NULL; - if( pBaseHash->pulPos ) + if( pBaseHash->pnPos ) { - hb_xfree( pBaseHash->pulPos ); - pBaseHash->pulPos = NULL; + hb_xfree( pBaseHash->pnPos ); + pBaseHash->pnPos = NULL; } } } @@ -344,64 +344,64 @@ static void hb_hashResize( PHB_BASEHASH pBaseHash, HB_SIZE ulNewSize ) static PHB_ITEM hb_hashValuePtr( PHB_BASEHASH pBaseHash, PHB_ITEM pKey, HB_BOOL fAdd ) { - HB_SIZE ulPos; + HB_SIZE nPos; - if( !hb_hashFind( pBaseHash, pKey, &ulPos ) ) + if( !hb_hashFind( pBaseHash, pKey, &nPos ) ) { if( !fAdd ) return NULL; - if( pBaseHash->ulSize == pBaseHash->ulLen ) - hb_hashResize( pBaseHash, pBaseHash->ulSize + HB_HASH_ITEM_ALLOC ); + if( pBaseHash->nSize == pBaseHash->nLen ) + hb_hashResize( pBaseHash, pBaseHash->nSize + HB_HASH_ITEM_ALLOC ); - if( pBaseHash->pulPos ) + if( pBaseHash->pnPos ) { - memmove( pBaseHash->pulPos + ulPos + 1, pBaseHash->pulPos + ulPos, - ( pBaseHash->ulLen - ulPos ) * sizeof( HB_SIZE ) ); - ulPos = ( pBaseHash->pulPos[ ulPos ] = pBaseHash->ulLen ); + memmove( pBaseHash->pnPos + nPos + 1, pBaseHash->pnPos + nPos, + ( pBaseHash->nLen - nPos ) * sizeof( HB_SIZE ) ); + nPos = ( pBaseHash->pnPos[ nPos ] = pBaseHash->nLen ); } - else if( ulPos < pBaseHash->ulLen ) + else if( nPos < pBaseHash->nLen ) { - 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; + memmove( pBaseHash->pPairs + nPos + 1, pBaseHash->pPairs + nPos, + ( pBaseHash->nLen - nPos ) * sizeof( HB_HASHPAIR ) ); + pBaseHash->pPairs[ nPos ].key.type = HB_IT_NIL; + pBaseHash->pPairs[ nPos ].value.type = HB_IT_NIL; } - hb_itemCopy( &pBaseHash->pPairs[ ulPos ].key, pKey ); - pBaseHash->ulLen++; + hb_itemCopy( &pBaseHash->pPairs[ nPos ].key, pKey ); + pBaseHash->nLen++; if( pBaseHash->pDefault ) - hb_itemCloneTo( &pBaseHash->pPairs[ ulPos ].value, pBaseHash->pDefault ); + hb_itemCloneTo( &pBaseHash->pPairs[ nPos ].value, pBaseHash->pDefault ); } - return &pBaseHash->pPairs[ ulPos ].value; + return &pBaseHash->pPairs[ nPos ].value; } static HB_BOOL hb_hashNewValue( PHB_BASEHASH pBaseHash, PHB_ITEM pKey, PHB_ITEM pValue ) { - HB_SIZE ulPos; + HB_SIZE nPos; - if( !hb_hashFind( pBaseHash, pKey, &ulPos ) ) + if( !hb_hashFind( pBaseHash, pKey, &nPos ) ) { - if( pBaseHash->ulSize == pBaseHash->ulLen ) - hb_hashResize( pBaseHash, pBaseHash->ulSize + HB_HASH_ITEM_ALLOC ); + if( pBaseHash->nSize == pBaseHash->nLen ) + hb_hashResize( pBaseHash, pBaseHash->nSize + HB_HASH_ITEM_ALLOC ); - if( pBaseHash->pulPos ) + if( pBaseHash->pnPos ) { - memmove( pBaseHash->pulPos + ulPos + 1, pBaseHash->pulPos + ulPos, - ( pBaseHash->ulLen - ulPos ) * sizeof( HB_SIZE ) ); - ulPos = ( pBaseHash->pulPos[ ulPos ] = pBaseHash->ulLen ); + memmove( pBaseHash->pnPos + nPos + 1, pBaseHash->pnPos + nPos, + ( pBaseHash->nLen - nPos ) * sizeof( HB_SIZE ) ); + nPos = ( pBaseHash->pnPos[ nPos ] = pBaseHash->nLen ); } - else if( ulPos < pBaseHash->ulLen ) + else if( nPos < pBaseHash->nLen ) { - 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; + memmove( pBaseHash->pPairs + nPos + 1, pBaseHash->pPairs + nPos, + ( pBaseHash->nLen - nPos ) * sizeof( HB_HASHPAIR ) ); + pBaseHash->pPairs[ nPos ].key.type = HB_IT_NIL; + pBaseHash->pPairs[ nPos ].value.type = HB_IT_NIL; } - hb_itemCopy( &pBaseHash->pPairs[ ulPos ].key, pKey ); - hb_itemCopyFromRef( &pBaseHash->pPairs[ ulPos ].value, pValue ); - pBaseHash->ulLen++; + hb_itemCopy( &pBaseHash->pPairs[ nPos ].key, pKey ); + hb_itemCopyFromRef( &pBaseHash->pPairs[ nPos ].value, pValue ); + pBaseHash->nLen++; return HB_TRUE; } @@ -411,29 +411,29 @@ static HB_BOOL hb_hashNewValue( PHB_BASEHASH pBaseHash, PHB_ITEM pKey, PHB_ITEM static void hb_hashNewPair( PHB_BASEHASH pBaseHash, PHB_ITEM * pKeyPtr, PHB_ITEM * pValPtr ) { - if( pBaseHash->ulSize == pBaseHash->ulLen ) - hb_hashResize( pBaseHash, pBaseHash->ulSize + HB_HASH_ITEM_ALLOC ); + if( pBaseHash->nSize == pBaseHash->nLen ) + hb_hashResize( pBaseHash, pBaseHash->nSize + HB_HASH_ITEM_ALLOC ); - if( pBaseHash->pulPos ) - pBaseHash->pulPos[ pBaseHash->ulLen ] = pBaseHash->ulLen; + if( pBaseHash->pnPos ) + pBaseHash->pnPos[ pBaseHash->nLen ] = pBaseHash->nLen; - * pKeyPtr = &pBaseHash->pPairs[ pBaseHash->ulLen ].key; - * pValPtr = &pBaseHash->pPairs[ pBaseHash->ulLen ].value; + * pKeyPtr = &pBaseHash->pPairs[ pBaseHash->nLen ].key; + * pValPtr = &pBaseHash->pPairs[ pBaseHash->nLen ].value; - pBaseHash->ulLen++; + pBaseHash->nLen++; } -static void hb_hashDelPair( PHB_BASEHASH pBaseHash, HB_SIZE ulPos ) +static void hb_hashDelPair( PHB_BASEHASH pBaseHash, HB_SIZE nPos ) { - if( --pBaseHash->ulLen == 0 ) + if( --pBaseHash->nLen == 0 ) { PHB_HASHPAIR pPairs = pBaseHash->pPairs; pBaseHash->pPairs = NULL; - pBaseHash->ulSize = 0; - if( pBaseHash->pulPos ) + pBaseHash->nSize = 0; + if( pBaseHash->pnPos ) { - hb_xfree( pBaseHash->pulPos ); - pBaseHash->pulPos = NULL; + hb_xfree( pBaseHash->pnPos ); + pBaseHash->pnPos = NULL; } if( HB_IS_COMPLEX( &pPairs->key ) ) hb_itemClear( &pPairs->key ); @@ -443,41 +443,41 @@ static void hb_hashDelPair( PHB_BASEHASH pBaseHash, HB_SIZE ulPos ) } else { - if( pBaseHash->pulPos ) + if( pBaseHash->pnPos ) { - HB_SIZE ul = 0; - while( ul < pBaseHash->ulLen ) + HB_SIZE n = 0; + while( n < pBaseHash->nLen ) { - if( pBaseHash->pulPos[ ul ] > ulPos ) - pBaseHash->pulPos[ ul++ ]--; - else if( pBaseHash->pulPos[ ul ] == ulPos ) - memmove( &pBaseHash->pulPos[ ul ], &pBaseHash->pulPos[ ul + 1 ], - ( pBaseHash->ulLen - ul ) * sizeof( HB_SIZE ) ); + if( pBaseHash->pnPos[ n ] > nPos ) + pBaseHash->pnPos[ n++ ]--; + else if( pBaseHash->pnPos[ n ] == nPos ) + memmove( &pBaseHash->pnPos[ n ], &pBaseHash->pnPos[ n + 1 ], + ( pBaseHash->nLen - n ) * sizeof( HB_SIZE ) ); else - ++ul; + ++n; } } - if( ulPos != pBaseHash->ulLen ) + if( nPos != pBaseHash->nLen ) { 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 ) ); - ulPos = pBaseHash->ulLen; - memcpy( pBaseHash->pPairs + ulPos, &pair, sizeof( HB_HASHPAIR ) ); + memcpy( &pair, pBaseHash->pPairs + nPos, sizeof( HB_HASHPAIR ) ); + memmove( pBaseHash->pPairs + nPos, pBaseHash->pPairs + nPos + 1, + ( pBaseHash->nLen - nPos ) * sizeof( HB_HASHPAIR ) ); + nPos = pBaseHash->nLen; + memcpy( pBaseHash->pPairs + nPos, &pair, sizeof( HB_HASHPAIR ) ); } - hb_itemSetNil( &pBaseHash->pPairs[ ulPos ].key ); - hb_itemSetNil( &pBaseHash->pPairs[ ulPos ].value ); - if( pBaseHash->ulSize - pBaseHash->ulLen > ( HB_HASH_ITEM_ALLOC << 1 ) ) + hb_itemSetNil( &pBaseHash->pPairs[ nPos ].key ); + hb_itemSetNil( &pBaseHash->pPairs[ nPos ].value ); + if( pBaseHash->nSize - pBaseHash->nLen > ( HB_HASH_ITEM_ALLOC << 1 ) ) { - pBaseHash->ulSize -= HB_HASH_ITEM_ALLOC; + pBaseHash->nSize -= HB_HASH_ITEM_ALLOC; pBaseHash->pPairs = ( PHB_HASHPAIR ) hb_xrealloc( pBaseHash->pPairs, - pBaseHash->ulSize * sizeof( HB_HASHPAIR ) ); - if( pBaseHash->pulPos ) - pBaseHash->pulPos = ( HB_SIZE * ) hb_xrealloc( pBaseHash->pulPos, - pBaseHash->ulSize * sizeof( HB_SIZE ) ); + pBaseHash->nSize * sizeof( HB_HASHPAIR ) ); + if( pBaseHash->pnPos ) + pBaseHash->pnPos = ( HB_SIZE * ) hb_xrealloc( pBaseHash->pnPos, + pBaseHash->nSize * sizeof( HB_SIZE ) ); } } } @@ -495,9 +495,9 @@ PHB_ITEM hb_hashNew( PHB_ITEM pItem ) pBaseHash = ( PHB_BASEHASH ) hb_gcAllocRaw( sizeof( HB_BASEHASH ), &s_gcHashFuncs ); pBaseHash->pPairs = NULL; - pBaseHash->pulPos = NULL; - pBaseHash->ulSize = 0; - pBaseHash->ulLen = 0; + pBaseHash->pnPos = NULL; + pBaseHash->nSize = 0; + pBaseHash->nLen = 0; pBaseHash->iFlags = HB_HASH_FLAG_DEFAULT; pBaseHash->pDefault = NULL; @@ -512,17 +512,17 @@ HB_SIZE 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; + return pHash->item.asHash.value->nLen; else return 0; } -void hb_hashPreallocate( PHB_ITEM pHash, HB_SIZE ulNewSize ) +void hb_hashPreallocate( PHB_ITEM pHash, HB_SIZE nNewSize ) { - HB_TRACE(HB_TR_DEBUG, ("hb_hashPreallocate(%p,%" HB_PFS "u)", pHash, ulNewSize)); + HB_TRACE(HB_TR_DEBUG, ("hb_hashPreallocate(%p,%" HB_PFS "u)", pHash, nNewSize)); if( HB_IS_HASH( pHash ) ) - hb_hashResize( pHash->item.asHash.value, ulNewSize ); + hb_hashResize( pHash->item.asHash.value, nNewSize ); } HB_BOOL hb_hashAllocNewPair( PHB_ITEM pHash, PHB_ITEM * pKeyPtr, PHB_ITEM * pValPtr ) @@ -586,7 +586,7 @@ PHB_ITEM hb_hashGetCItemPtr( PHB_ITEM pHash, const char * pszKey ) HB_SIZE hb_hashGetCItemPos( PHB_ITEM pHash, const char * pszKey ) { - HB_SIZE ulPos = 0; + HB_SIZE nPos = 0; HB_TRACE(HB_TR_DEBUG, ("hb_hashGetCItemPos(%p,%s)", pHash, pszKey)); @@ -598,14 +598,14 @@ HB_SIZE hb_hashGetCItemPos( PHB_ITEM pHash, const char * pszKey ) */ PHB_ITEM pKey = hb_itemPutCConst( hb_stackAllocItem(), pszKey ); - if( hb_hashFind( pHash->item.asHash.value, pKey, &ulPos ) ) - ulPos++; + if( hb_hashFind( pHash->item.asHash.value, pKey, &nPos ) ) + nPos++; else - ulPos = 0; + nPos = 0; hb_stackPop(); } - return ulPos; + return nPos; } PHB_ITEM hb_hashGetItemRefPtr( PHB_ITEM pHash, PHB_ITEM pKey ) @@ -628,27 +628,27 @@ PHB_ITEM hb_hashGetItemRefPtr( PHB_ITEM pHash, PHB_ITEM pKey ) return NULL; } -HB_BOOL hb_hashScan( PHB_ITEM pHash, PHB_ITEM pKey, HB_SIZE * pulPos ) +HB_BOOL hb_hashScan( PHB_ITEM pHash, PHB_ITEM pKey, HB_SIZE * pnPos ) { - HB_TRACE(HB_TR_DEBUG, ("hb_hashScan(%p,%p,%p)", pHash, pKey, pulPos)); + HB_TRACE(HB_TR_DEBUG, ("hb_hashScan(%p,%p,%p)", pHash, pKey, pnPos)); if( HB_IS_HASH( pHash ) ) { - HB_SIZE ulPos; + HB_SIZE nPos; if( HB_IS_HASHKEY( pKey ) ) { - if( hb_hashFind( pHash->item.asHash.value, pKey, &ulPos ) ) + if( hb_hashFind( pHash->item.asHash.value, pKey, &nPos ) ) { - if( pulPos ) - *pulPos = ulPos + 1; + if( pnPos ) + *pnPos = nPos + 1; return HB_TRUE; } } - else if( HB_IS_HASH( pKey ) && pKey->item.asHash.value->ulLen == 1 ) + else if( HB_IS_HASH( pKey ) && pKey->item.asHash.value->nLen == 1 ) { - if( hb_hashFind( pHash->item.asHash.value, &pKey->item.asHash.value->pPairs[ 0 ].key, &ulPos ) ) + if( hb_hashFind( pHash->item.asHash.value, &pKey->item.asHash.value->pPairs[ 0 ].key, &nPos ) ) { - PHB_ITEM pVal1 = &pHash->item.asHash.value->pPairs[ ulPos ].value; + PHB_ITEM pVal1 = &pHash->item.asHash.value->pPairs[ nPos ].value; PHB_ITEM pVal2 = &pKey->item.asHash.value->pPairs[ 0 ].value; HB_BOOL fResult = HB_FALSE; if( HB_IS_STRING( pVal1 ) && HB_IS_STRING( pVal2 ) ) @@ -672,15 +672,15 @@ HB_BOOL hb_hashScan( PHB_ITEM pHash, PHB_ITEM pKey, HB_SIZE * pulPos ) } if( fResult ) { - if( pulPos ) - *pulPos = ulPos + 1; + if( pnPos ) + *pnPos = nPos + 1; return HB_TRUE; } } } } - if( pulPos ) - *pulPos = 0; + if( pnPos ) + *pnPos = 0; return HB_FALSE; } @@ -690,29 +690,29 @@ static HB_BOOL hb_hashClear( PHB_ITEM pHash ) if( HB_IS_HASH( pHash ) ) { - if( pHash->item.asHash.value->ulSize ) + if( pHash->item.asHash.value->nSize ) { - while( pHash->item.asHash.value->ulLen ) + while( pHash->item.asHash.value->nLen ) { - 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 ); + pHash->item.asHash.value->nLen--; + if( HB_IS_COMPLEX( &pHash->item.asHash.value->pPairs[ pHash->item.asHash.value->nLen ].key ) ) + hb_itemClear( &pHash->item.asHash.value->pPairs[ pHash->item.asHash.value->nLen ].key ); + if( HB_IS_COMPLEX( &pHash->item.asHash.value->pPairs[ pHash->item.asHash.value->nLen ].value ) ) + hb_itemClear( &pHash->item.asHash.value->pPairs[ pHash->item.asHash.value->nLen ].value ); } /* * This condition is a protection against recursive call * from .prg object destructor [druzus] */ - if( pHash->item.asHash.value->ulSize ) + if( pHash->item.asHash.value->nSize ) { hb_xfree( pHash->item.asHash.value->pPairs ); pHash->item.asHash.value->pPairs = NULL; - pHash->item.asHash.value->ulSize = 0; - if( pHash->item.asHash.value->pulPos ) + pHash->item.asHash.value->nSize = 0; + if( pHash->item.asHash.value->pnPos ) { - hb_xfree( pHash->item.asHash.value->pulPos ); - pHash->item.asHash.value->pulPos = NULL; + hb_xfree( pHash->item.asHash.value->pnPos ); + pHash->item.asHash.value->pnPos = NULL; } } } @@ -729,11 +729,11 @@ HB_BOOL hb_hashDel( PHB_ITEM pHash, PHB_ITEM pKey ) if( HB_IS_HASH( pHash ) && HB_IS_HASHKEY( pKey ) ) { PHB_BASEHASH pBaseHash = pHash->item.asHash.value; - HB_SIZE ulPos; + HB_SIZE nPos; - if( hb_hashFind( pBaseHash, pKey, &ulPos ) ) + if( hb_hashFind( pBaseHash, pKey, &nPos ) ) { - hb_hashDelPair( pBaseHash, ulPos ); + hb_hashDelPair( pBaseHash, nPos ); return HB_TRUE; } } @@ -754,9 +754,9 @@ HB_BOOL hb_hashRemove( PHB_ITEM pHash, PHB_ITEM pItem ) } else if( HB_IS_ARRAY( pItem ) ) { - HB_SIZE ul = 0; + HB_SIZE n = 0; PHB_ITEM pKey; - while( ( pKey = hb_arrayGetItemPtr( pItem, ++ul ) ) != NULL ) + while( ( pKey = hb_arrayGetItemPtr( pItem, ++n ) ) != NULL ) hb_hashDel( pHash, pKey ); return HB_TRUE; } @@ -766,9 +766,9 @@ HB_BOOL hb_hashRemove( PHB_ITEM pHash, PHB_ITEM pItem ) hb_hashClear( pHash ); else { - HB_SIZE ulLen = 0; - while( ulLen < pItem->item.asHash.value->ulLen ) - hb_hashDel( pHash, &pItem->item.asHash.value->pPairs[ ulLen++ ].key ); + HB_SIZE nLen = 0; + while( nLen < pItem->item.asHash.value->nLen ) + hb_hashDel( pHash, &pItem->item.asHash.value->pPairs[ nLen++ ].key ); } return HB_TRUE; } @@ -808,36 +808,36 @@ HB_BOOL hb_hashAddNew( PHB_ITEM pHash, PHB_ITEM pKey, PHB_ITEM pValue ) return HB_FALSE; } -PHB_ITEM hb_hashGetKeyAt( PHB_ITEM pHash, HB_SIZE ulPos ) +PHB_ITEM hb_hashGetKeyAt( PHB_ITEM pHash, HB_SIZE nPos ) { - HB_TRACE(HB_TR_DEBUG, ("hb_hashGetKeyAt(%p,%" HB_PFS "u)", pHash, ulPos)); + HB_TRACE(HB_TR_DEBUG, ("hb_hashGetKeyAt(%p,%" HB_PFS "u)", pHash, nPos)); - if( HB_IS_HASH( pHash ) && ulPos > 0 && ulPos <= pHash->item.asHash.value->ulLen ) - return &pHash->item.asHash.value->pPairs[ ulPos - 1 ].key; + if( HB_IS_HASH( pHash ) && nPos > 0 && nPos <= pHash->item.asHash.value->nLen ) + return &pHash->item.asHash.value->pPairs[ nPos - 1 ].key; else return NULL; } -PHB_ITEM hb_hashGetValueAt( PHB_ITEM pHash, HB_SIZE ulPos ) +PHB_ITEM hb_hashGetValueAt( PHB_ITEM pHash, HB_SIZE nPos ) { - HB_TRACE(HB_TR_DEBUG, ("hb_hashGetValueAt(%p,%" HB_PFS "u)", pHash, ulPos)); + HB_TRACE(HB_TR_DEBUG, ("hb_hashGetValueAt(%p,%" HB_PFS "u)", pHash, nPos)); - if( HB_IS_HASH( pHash ) && ulPos > 0 && ulPos <= pHash->item.asHash.value->ulLen ) + if( HB_IS_HASH( pHash ) && nPos > 0 && nPos <= pHash->item.asHash.value->nLen ) { - PHB_ITEM pValue = &pHash->item.asHash.value->pPairs[ ulPos - 1 ].value; + PHB_ITEM pValue = &pHash->item.asHash.value->pPairs[ nPos - 1 ].value; return HB_IS_BYREF( pValue ) ? hb_itemUnRef( pValue ) : pValue; } else return NULL; } -HB_BOOL hb_hashDelAt( PHB_ITEM pHash, HB_SIZE ulPos ) +HB_BOOL hb_hashDelAt( PHB_ITEM pHash, HB_SIZE nPos ) { - HB_TRACE(HB_TR_DEBUG, ("hb_hashDelAt(%p,%" HB_PFS "u)", pHash, ulPos)); + HB_TRACE(HB_TR_DEBUG, ("hb_hashDelAt(%p,%" HB_PFS "u)", pHash, nPos)); - if( HB_IS_HASH( pHash ) && ulPos > 0 && ulPos <= pHash->item.asHash.value->ulLen ) + if( HB_IS_HASH( pHash ) && nPos > 0 && nPos <= pHash->item.asHash.value->nLen ) { - hb_hashDelPair( pHash->item.asHash.value, ulPos - 1 ); + hb_hashDelPair( pHash->item.asHash.value, nPos - 1 ); return HB_TRUE; } else @@ -857,32 +857,32 @@ void * hb_hashId( PHB_ITEM pHash ) void hb_hashCloneBody( PHB_ITEM pHash, PHB_ITEM pDest, PHB_NESTED_CLONED pClonedList ) { - HB_SIZE ulPos; + HB_SIZE nPos; HB_TRACE(HB_TR_DEBUG, ("hb_hashCloneBody(%p,%p,%p)", pHash, pDest, pClonedList)); hb_hashNew( pDest ); pDest->item.asHash.value->iFlags = pHash->item.asHash.value->iFlags; - hb_hashResize( pDest->item.asHash.value, pHash->item.asHash.value->ulLen ); + hb_hashResize( pDest->item.asHash.value, pHash->item.asHash.value->nLen ); if( pHash->item.asHash.value->pDefault ) { pDest->item.asHash.value->pDefault = hb_itemNew( pHash->item.asHash.value->pDefault ); hb_gcUnlock( pDest->item.asHash.value->pDefault ); } - if( pHash->item.asHash.value->pulPos ) - memcpy( pDest->item.asHash.value->pulPos, - pHash->item.asHash.value->pulPos, - pHash->item.asHash.value->ulLen * sizeof( HB_SIZE ) ); - for( ulPos = 0; ulPos < pHash->item.asHash.value->ulLen; ++ulPos ) + if( pHash->item.asHash.value->pnPos ) + memcpy( pDest->item.asHash.value->pnPos, + pHash->item.asHash.value->pnPos, + pHash->item.asHash.value->nLen * sizeof( HB_SIZE ) ); + for( nPos = 0; nPos < pHash->item.asHash.value->nLen; ++nPos ) { - PHB_ITEM pValue = &pHash->item.asHash.value->pPairs[ ulPos ].value; + PHB_ITEM pValue = &pHash->item.asHash.value->pPairs[ nPos ].value; if( HB_IS_BYREF( pValue ) ) 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 ); + hb_itemCopy( &pDest->item.asHash.value->pPairs[ nPos ].key, + &pHash->item.asHash.value->pPairs[ nPos ].key ); + pDest->item.asHash.value->nLen++; + hb_cloneNested( &pDest->item.asHash.value->pPairs[ nPos ].value, pValue, pClonedList ); } } @@ -927,41 +927,41 @@ void hb_hashJoin( PHB_ITEM pDest, PHB_ITEM pSource, int iType ) if( HB_IS_HASH( pDest ) && HB_IS_HASH( pSource ) ) { PHB_BASEHASH pBaseHash; - HB_SIZE ulPos; + HB_SIZE nPos; switch( iType ) { case HB_HASH_UNION: /* OR */ pBaseHash = pSource->item.asHash.value; - for( ulPos = 0; ulPos < pBaseHash->ulLen; ++ulPos ) + for( nPos = 0; nPos < pBaseHash->nLen; ++nPos ) { - PHB_ITEM pVal = &pBaseHash->pPairs[ ulPos ].value; + PHB_ITEM pVal = &pBaseHash->pPairs[ nPos ].value; if( HB_IS_BYREF( pVal ) ) pVal = hb_itemUnRef( pVal ); - hb_hashAdd( pDest, &pBaseHash->pPairs[ ulPos ].key, pVal ); + hb_hashAdd( pDest, &pBaseHash->pPairs[ nPos ].key, pVal ); } break; case HB_HASH_INTERSECT: /* AND */ pBaseHash = pDest->item.asHash.value; - for( ulPos = 0; ulPos < pBaseHash->ulLen; ++ulPos ) + for( nPos = 0; nPos < pBaseHash->nLen; ++nPos ) { if( !hb_hashFind( pSource->item.asHash.value, - &pBaseHash->pPairs[ ulPos ].key, NULL ) ) - hb_hashDel( pDest, &pBaseHash->pPairs[ ulPos ].key ); + &pBaseHash->pPairs[ nPos ].key, NULL ) ) + hb_hashDel( pDest, &pBaseHash->pPairs[ nPos ].key ); } break; case HB_HASH_DIFFERENCE: /* XOR */ pBaseHash = pSource->item.asHash.value; - for( ulPos = 0; ulPos < pBaseHash->ulLen; ++ulPos ) + for( nPos = 0; nPos < pBaseHash->nLen; ++nPos ) { - if( !hb_hashDel( pDest, &pBaseHash->pPairs[ ulPos ].key ) ) + if( !hb_hashDel( pDest, &pBaseHash->pPairs[ nPos ].key ) ) { - PHB_ITEM pVal = &pBaseHash->pPairs[ ulPos ].value; + PHB_ITEM pVal = &pBaseHash->pPairs[ nPos ].value; if( HB_IS_BYREF( pVal ) ) pVal = hb_itemUnRef( pVal ); - hb_hashAdd( pDest, &pBaseHash->pPairs[ ulPos ].key, pVal ); + hb_hashAdd( pDest, &pBaseHash->pPairs[ nPos ].key, pVal ); } } break; @@ -972,8 +972,8 @@ void hb_hashJoin( PHB_ITEM pDest, PHB_ITEM pSource, int iType ) hb_hashClear( pDest ); else { - for( ulPos = 0; ulPos < pBaseHash->ulLen; ++ulPos ) - hb_hashDel( pDest, &pBaseHash->pPairs[ ulPos ].key ); + for( nPos = 0; nPos < pBaseHash->nLen; ++nPos ) + hb_hashDel( pDest, &pBaseHash->pPairs[ nPos ].key ); } break; } @@ -987,11 +987,11 @@ PHB_ITEM hb_hashGetKeys( PHB_ITEM pHash ) if( HB_IS_HASH( pHash ) ) { PHB_ITEM pKeys = hb_itemArrayNew( hb_hashLen( pHash ) ), pKey; - HB_SIZE ulPos = 0; + HB_SIZE nPos = 0; - while( ( pKey = hb_hashGetKeyAt( pHash, ++ulPos ) ) != NULL ) + while( ( pKey = hb_hashGetKeyAt( pHash, ++nPos ) ) != NULL ) { - PHB_ITEM pDest = hb_arrayGetItemPtr( pKeys, ulPos ); + PHB_ITEM pDest = hb_arrayGetItemPtr( pKeys, nPos ); if( !pDest ) break; hb_itemCopy( pDest, pKey ); @@ -1009,11 +1009,11 @@ PHB_ITEM hb_hashGetValues( PHB_ITEM pHash ) if( HB_IS_HASH( pHash ) ) { PHB_ITEM pValues = hb_itemArrayNew( hb_hashLen( pHash ) ), pVal; - HB_SIZE ulPos = 0; + HB_SIZE nPos = 0; - while( ( pVal = hb_hashGetValueAt( pHash, ++ulPos ) ) != NULL ) + while( ( pVal = hb_hashGetValueAt( pHash, ++nPos ) ) != NULL ) { - PHB_ITEM pDest = hb_arrayGetItemPtr( pValues, ulPos ); + PHB_ITEM pDest = hb_arrayGetItemPtr( pValues, nPos ); if( !pDest ) break; hb_itemCopy( pDest, pVal ); @@ -1062,20 +1062,20 @@ void hb_hashSetFlags( PHB_ITEM pHash, int iFlags ) if( HB_IS_HASH( pHash ) ) { pHash->item.asHash.value->iFlags |= iFlags; - if( pHash->item.asHash.value->pulPos == NULL && - pHash->item.asHash.value->ulSize && + if( pHash->item.asHash.value->pnPos == NULL && + pHash->item.asHash.value->nSize && ( pHash->item.asHash.value->iFlags & HB_HASH_KEEPORDER ) != 0 ) { - HB_SIZE ul = pHash->item.asHash.value->ulSize; + HB_SIZE n = pHash->item.asHash.value->nSize; - pHash->item.asHash.value->pulPos = ( HB_SIZE * ) - hb_xgrab( pHash->item.asHash.value->ulSize * sizeof( HB_SIZE ) ); + pHash->item.asHash.value->pnPos = ( HB_SIZE * ) + hb_xgrab( pHash->item.asHash.value->nSize * sizeof( HB_SIZE ) ); do { - --ul; - pHash->item.asHash.value->pulPos[ ul ] = ul; + --n; + pHash->item.asHash.value->pnPos[ n ] = n; } - while( ul ); + while( n ); } } } @@ -1087,11 +1087,11 @@ void hb_hashClearFlags( PHB_ITEM pHash, int iFlags ) if( HB_IS_HASH( pHash ) ) { pHash->item.asHash.value->iFlags &= ~iFlags; - if( pHash->item.asHash.value->pulPos != NULL && + if( pHash->item.asHash.value->pnPos != NULL && ( pHash->item.asHash.value->iFlags & HB_HASH_KEEPORDER ) == 0 ) { - hb_xfree( pHash->item.asHash.value->pulPos ); - pHash->item.asHash.value->pulPos = NULL; + hb_xfree( pHash->item.asHash.value->pnPos ); + pHash->item.asHash.value->pnPos = NULL; } } } diff --git a/harbour/src/vm/hashfunc.c b/harbour/src/vm/hashfunc.c index fc05faa417..19135d35a0 100644 --- a/harbour/src/vm/hashfunc.c +++ b/harbour/src/vm/hashfunc.c @@ -101,9 +101,9 @@ HB_FUNC( HB_HPOS ) if( pHash && pKey ) { - HB_SIZE ulPos; - hb_hashScan( pHash, pKey, &ulPos ); - hb_retns( ulPos ); + HB_SIZE nPos; + hb_hashScan( pHash, pKey, &nPos ); + hb_retns( nPos ); } else hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); @@ -297,9 +297,9 @@ HB_FUNC( HB_HFILL ) if( pHash && pValue ) { PHB_ITEM pDest; - HB_SIZE ulPos = 0; + HB_SIZE nPos = 0; - while( ( pDest = hb_hashGetValueAt( pHash, ++ulPos ) ) != NULL ) + while( ( pDest = hb_hashGetValueAt( pHash, ++nPos ) ) != NULL ) hb_itemCopy( pDest, pValue ); hb_itemReturn( pHash ); @@ -325,22 +325,22 @@ HB_FUNC( HB_HCOPY ) if( pSource && pDest ) { - HB_SIZE ulLen = hb_hashLen( pSource ), ulStart, ulCount; + HB_SIZE nLen = hb_hashLen( pSource ), nStart, nCount; - ulStart = hb_parns( 3 ); - if( !ulStart ) - ++ulStart; - ulCount = HB_ISNUM( 4 ) ? ( HB_SIZE ) hb_parns( 4 ) : ulLen - ulStart + 1; + nStart = hb_parns( 3 ); + if( !nStart ) + ++nStart; + nCount = HB_ISNUM( 4 ) ? ( HB_SIZE ) hb_parns( 4 ) : nLen - nStart + 1; - while( ulCount-- ) + while( nCount-- ) { - PHB_ITEM pKey = hb_hashGetKeyAt( pSource, ulStart ); - PHB_ITEM pValue = hb_hashGetValueAt( pSource, ulStart ); + PHB_ITEM pKey = hb_hashGetKeyAt( pSource, nStart ); + PHB_ITEM pValue = hb_hashGetValueAt( pSource, nStart ); if( pKey && pValue ) hb_hashAdd( pDest, pKey, pValue ); else break; - ++ulStart; + ++nStart; } hb_itemReturn( pDest ); @@ -359,18 +359,18 @@ HB_FUNC( HB_HMERGE ) { if( pAction && HB_IS_BLOCK( pAction ) ) { - HB_SIZE ulLen = hb_hashLen( pSource ), ulPos = 0; - while( ++ulPos <= ulLen ) + HB_SIZE nLen = hb_hashLen( pSource ), nPos = 0; + while( ++nPos <= nLen ) { - PHB_ITEM pKey = hb_hashGetKeyAt( pSource, ulPos ); - PHB_ITEM pValue = hb_hashGetValueAt( pSource, ulPos ); + PHB_ITEM pKey = hb_hashGetKeyAt( pSource, nPos ); + PHB_ITEM pValue = hb_hashGetValueAt( pSource, nPos ); if( pKey && pValue ) { hb_vmPushEvalSym(); hb_vmPush( pAction ); hb_vmPush( pKey ); hb_vmPush( pValue ); - hb_vmPushSize( ulPos ); + hb_vmPushSize( nPos ); hb_vmSend( 3 ); { PHB_ITEM pReturn = hb_stackReturnItem(); @@ -398,29 +398,29 @@ HB_FUNC( HB_HEVAL ) if( pHash && pBlock ) { - HB_SIZE ulLen = hb_hashLen( pHash ), ulStart, ulCount; + HB_SIZE nLen = hb_hashLen( pHash ), nStart, nCount; - ulStart = hb_parns( 3 ); - if( !ulStart ) - ++ulStart; - ulCount = HB_ISNUM( 4 ) ? ( HB_SIZE ) hb_parns( 4 ) : ulLen - ulStart + 1; + nStart = hb_parns( 3 ); + if( !nStart ) + ++nStart; + nCount = HB_ISNUM( 4 ) ? ( HB_SIZE ) hb_parns( 4 ) : nLen - nStart + 1; - while( ulCount-- ) + while( nCount-- ) { - PHB_ITEM pKey = hb_hashGetKeyAt( pHash, ulStart ); - PHB_ITEM pValue = hb_hashGetValueAt( pHash, ulStart ); + PHB_ITEM pKey = hb_hashGetKeyAt( pHash, nStart ); + PHB_ITEM pValue = hb_hashGetValueAt( pHash, nStart ); if( pKey && pValue ) { hb_vmPushEvalSym(); hb_vmPush( pBlock ); hb_vmPush( pKey ); hb_vmPush( pValue ); - hb_vmPushSize( ulStart ); + hb_vmPushSize( nStart ); hb_vmSend( 3 ); } else break; - ++ulStart; + ++nStart; } hb_itemReturn( pHash ); @@ -437,26 +437,26 @@ HB_FUNC( HB_HSCAN ) if( pHash && pValue ) { HB_BOOL fExact = hb_parl( 5 ), fFound = HB_FALSE; - HB_SIZE ulLen = hb_hashLen( pHash ), ulStart, ulCount; + HB_SIZE nLen = hb_hashLen( pHash ), nStart, nCount; - ulStart = hb_parns( 3 ); - if( !ulStart ) - ++ulStart; - ulCount = HB_ISNUM( 4 ) ? ( HB_SIZE ) hb_parns( 4 ) : ulLen - ulStart + 1; + nStart = hb_parns( 3 ); + if( !nStart ) + ++nStart; + nCount = HB_ISNUM( 4 ) ? ( HB_SIZE ) hb_parns( 4 ) : nLen - nStart + 1; if( HB_IS_BLOCK( pValue ) ) { - while( ulCount-- ) + while( nCount-- ) { - PHB_ITEM pKey = hb_hashGetKeyAt( pHash, ulStart ); - PHB_ITEM pVal = hb_hashGetValueAt( pHash, ulStart ); + PHB_ITEM pKey = hb_hashGetKeyAt( pHash, nStart ); + PHB_ITEM pVal = hb_hashGetValueAt( pHash, nStart ); if( pKey && pValue ) { hb_vmPushEvalSym(); hb_vmPush( pValue ); hb_vmPush( pKey ); hb_vmPush( pVal ); - hb_vmPushSize( ulStart ); + hb_vmPushSize( nStart ); hb_vmSend( 3 ); { PHB_ITEM pReturn = hb_stackReturnItem(); @@ -469,14 +469,14 @@ HB_FUNC( HB_HSCAN ) } else break; - ++ulStart; + ++nStart; } } else if( HB_IS_STRING( pValue ) ) { - while( ulCount-- ) + while( nCount-- ) { - PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart ); + PHB_ITEM pItem = hb_hashGetValueAt( pHash, nStart ); if( pItem ) { if( HB_IS_STRING( pItem ) && hb_itemStrCmp( pItem, pValue, fExact ) == 0 ) @@ -487,15 +487,15 @@ HB_FUNC( HB_HSCAN ) } else break; - ++ulStart; + ++nStart; } } else if( HB_IS_NUMERIC( pValue ) ) { double dValue = hb_itemGetND( pValue ); - while( ulCount-- ) + while( nCount-- ) { - PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart ); + PHB_ITEM pItem = hb_hashGetValueAt( pHash, nStart ); if( pItem ) { if( HB_IS_NUMERIC( pItem ) && hb_itemGetND( pItem ) == dValue ) @@ -506,14 +506,14 @@ HB_FUNC( HB_HSCAN ) } else break; - ++ulStart; + ++nStart; } } else if( HB_IS_DATETIME( pValue ) ) { - while( ulCount-- ) + while( nCount-- ) { - PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart ); + PHB_ITEM pItem = hb_hashGetValueAt( pHash, nStart ); if( pItem ) { if( HB_IS_DATETIME( pItem ) && @@ -526,15 +526,15 @@ HB_FUNC( HB_HSCAN ) } else break; - ++ulStart; + ++nStart; } } else if( HB_IS_LOGICAL( pValue ) ) { HB_BOOL fValue = hb_itemGetDL( pValue ); - while( ulCount-- ) + while( nCount-- ) { - PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart ); + PHB_ITEM pItem = hb_hashGetValueAt( pHash, nStart ); if( pItem ) { if( HB_IS_LOGICAL( pItem ) && hb_itemGetL( pItem ) == fValue ) @@ -545,14 +545,14 @@ HB_FUNC( HB_HSCAN ) } else break; - ++ulStart; + ++nStart; } } else if( HB_IS_NIL( pValue ) ) { - while( ulCount-- ) + while( nCount-- ) { - PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart ); + PHB_ITEM pItem = hb_hashGetValueAt( pHash, nStart ); if( pItem ) { if( HB_IS_NIL( pItem ) ) @@ -563,14 +563,14 @@ HB_FUNC( HB_HSCAN ) } else break; - ++ulStart; + ++nStart; } } else if( HB_IS_POINTER( pValue ) ) { - while( ulCount-- ) + while( nCount-- ) { - PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart ); + PHB_ITEM pItem = hb_hashGetValueAt( pHash, nStart ); if( pItem ) { if( HB_IS_POINTER( pItem ) && @@ -582,14 +582,14 @@ HB_FUNC( HB_HSCAN ) } else break; - ++ulStart; + ++nStart; } } else if( fExact && HB_IS_ARRAY( pValue ) ) { - while( ulCount-- ) + while( nCount-- ) { - PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart ); + PHB_ITEM pItem = hb_hashGetValueAt( pHash, nStart ); if( pItem ) { if( HB_IS_ARRAY( pItem ) && @@ -601,14 +601,14 @@ HB_FUNC( HB_HSCAN ) } else break; - ++ulStart; + ++nStart; } } else if( fExact && HB_IS_HASH( pValue ) ) { - while( ulCount-- ) + while( nCount-- ) { - PHB_ITEM pItem = hb_hashGetValueAt( pHash, ulStart ); + PHB_ITEM pItem = hb_hashGetValueAt( pHash, nStart ); if( pItem ) { if( HB_IS_HASH( pItem ) && @@ -620,11 +620,11 @@ HB_FUNC( HB_HSCAN ) } else break; - ++ulStart; + ++nStart; } } - hb_retns( fFound ? ulStart : 0 ); + hb_retns( fFound ? nStart : 0 ); } else hb_errRT_BASE( EG_ARG, 1123, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); diff --git a/harbour/src/vm/hvm.c b/harbour/src/vm/hvm.c index 49bd4d4ebd..f3c41b2577 100644 --- a/harbour/src/vm/hvm.c +++ b/harbour/src/vm/hvm.c @@ -143,8 +143,8 @@ static void hb_vmArrayPush( void ); /* pushes an array element to the s static void hb_vmArrayPushRef( void ); /* pushes a reference to an array element to the stack, removing the array and the index from the stack */ static void hb_vmArrayPop( void ); /* pops a value from the stack */ static void hb_vmArrayDim( HB_USHORT uiDimensions ); /* generates an uiDimensions Array and initialize those dimensions from the stack values */ -static void hb_vmArrayGen( HB_SIZE ulElements ); /* generates an ulElements Array and fills it from the stack values */ -static void hb_vmHashGen( HB_SIZE ulElements ); /* generates an ulElements Hash and fills it from the stack values */ +static void hb_vmArrayGen( HB_SIZE nElements ); /* generates an nElements Array and fills it from the stack values */ +static void hb_vmHashGen( HB_SIZE nElements ); /* generates an nElements Hash and fills it from the stack values */ /* macros */ static void hb_vmMacroDo( HB_USHORT uiArgSets ); /* execute function passing arguments set(s) on HVM stack func( &var ) */ @@ -170,9 +170,9 @@ static void hb_vmStaticsRelease( void ); /* release arrays with static va static void hb_vmPushAlias( void ); /* pushes the current workarea number */ static void hb_vmPushAliasedField( PHB_SYMB ); /* pushes an aliased field on the eval stack */ static void hb_vmPushAliasedVar( PHB_SYMB ); /* pushes an aliased variable on the eval stack */ -static void hb_vmPushBlock( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SIZE ulLen ); /* creates a codeblock */ -static void hb_vmPushBlockShort( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SIZE ulLen ); /* creates a codeblock */ -static void hb_vmPushMacroBlock( const HB_BYTE * pCode, HB_SIZE ulSize, HB_USHORT usParams ); /* creates a macro-compiled codeblock */ +static void hb_vmPushBlock( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SIZE nLen ); /* creates a codeblock */ +static void hb_vmPushBlockShort( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SIZE nLen ); /* creates a codeblock */ +static void hb_vmPushMacroBlock( const HB_BYTE * pCode, HB_SIZE nSize, HB_USHORT usParams ); /* creates a macro-compiled codeblock */ static void hb_vmPushDoubleConst( double dNumber, int iWidth, int iDec ); /* Pushes a double constant (pcode) */ static void hb_vmPushLocal( int iLocal ); /* pushes the containts of a local onto the stack */ static void hb_vmPushLocalByRef( int iLocal ); /* pushes a local by refrence onto the stack */ @@ -2172,21 +2172,21 @@ void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) case HB_P_PUSHSTRLARGE: { - HB_SIZE ulSize = HB_PCODE_MKUINT24( &pCode[ 1 ] ); + HB_SIZE nSize = HB_PCODE_MKUINT24( &pCode[ 1 ] ); if( bDynCode ) - hb_vmPushString( ( const char * ) pCode + 4, ulSize - 1 ); + hb_vmPushString( ( const char * ) pCode + 4, nSize - 1 ); else - hb_vmPushStringPcode( ( const char * ) pCode + 4, ulSize - 1 ); - pCode += 4 + ulSize; + hb_vmPushStringPcode( ( const char * ) pCode + 4, nSize - 1 ); + pCode += 4 + nSize; break; } case HB_P_PUSHSTRHIDDEN: { - HB_SIZE ulSize = ( HB_SIZE ) HB_PCODE_MKUSHORT( &pCode[ 2 ] ); - char * szText = hb_compDecodeString( pCode[ 1 ], ( const char * ) pCode + 4, &ulSize ); - hb_itemPutCLPtr( hb_stackAllocItem(), szText, ulSize ); - pCode += ( 4 + ulSize ); + HB_SIZE nSize = ( HB_SIZE ) HB_PCODE_MKUSHORT( &pCode[ 2 ] ); + char * szText = hb_compDecodeString( pCode[ 1 ], ( const char * ) pCode + 4, &nSize ); + hb_itemPutCLPtr( hb_stackAllocItem(), szText, nSize ); + pCode += ( 4 + nSize ); break; } @@ -2222,9 +2222,9 @@ void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) * +5 +6 -> number of referenced local variables * +7 -> start of table with referenced local variables */ - HB_SIZE ulSize = HB_PCODE_MKUSHORT( &pCode[ 1 ] ); - hb_vmPushBlock( pCode + 3, pSymbols, bDynCode ? ulSize - 7 : 0 ); - pCode += ulSize; + HB_SIZE nSize = HB_PCODE_MKUSHORT( &pCode[ 1 ] ); + hb_vmPushBlock( pCode + 3, pSymbols, bDynCode ? nSize - 7 : 0 ); + pCode += nSize; break; } case HB_P_PUSHBLOCKLARGE: @@ -2235,9 +2235,9 @@ void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) * +6 +7 -> number of referenced local variables * +8 -> start of table with referenced local variables */ - HB_SIZE ulSize = HB_PCODE_MKUINT24( &pCode[ 1 ] ); - hb_vmPushBlock( pCode + 4, pSymbols, bDynCode ? ulSize - 8 : 0 ); - pCode += ulSize; + HB_SIZE nSize = HB_PCODE_MKUINT24( &pCode[ 1 ] ); + hb_vmPushBlock( pCode + 4, pSymbols, bDynCode ? nSize - 8 : 0 ); + pCode += nSize; break; } case HB_P_PUSHBLOCKSHORT: @@ -2245,9 +2245,9 @@ void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) /* +0 -> _pushblock * +1 -> size of codeblock */ - HB_SIZE ulSize = pCode[ 1 ]; - hb_vmPushBlockShort( pCode + 2, pSymbols, bDynCode ? ulSize - 2 : 0 ); - pCode += ulSize; + HB_SIZE nSize = pCode[ 1 ]; + hb_vmPushBlockShort( pCode + 2, pSymbols, bDynCode ? nSize - 2 : 0 ); + pCode += nSize; break; } @@ -2642,10 +2642,10 @@ void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) * +3 +4 -> number of expected parameters * +5 -> pcode bytes */ - HB_SIZE ulSize = HB_PCODE_MKUSHORT( &pCode[ 1 ] ); - hb_vmPushMacroBlock( pCode + 5, ulSize - 5, + HB_SIZE nSize = HB_PCODE_MKUSHORT( &pCode[ 1 ] ); + hb_vmPushMacroBlock( pCode + 5, nSize - 5, HB_PCODE_MKUSHORT( &pCode[ 3 ] ) ); - pCode += ulSize; + pCode += nSize; break; } @@ -2660,10 +2660,10 @@ void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) * +4 +5 -> number of expected parameters * +6 -> pcode bytes */ - HB_SIZE ulSize = HB_PCODE_MKUINT24( &pCode[ 1 ] ); - hb_vmPushMacroBlock( pCode + 6, ulSize - 6, + HB_SIZE nSize = HB_PCODE_MKUINT24( &pCode[ 1 ] ); + hb_vmPushMacroBlock( pCode + 6, nSize - 6, HB_PCODE_MKUSHORT( &pCode[ 4 ] ) ); - pCode += ulSize; + pCode += nSize; break; } @@ -2723,10 +2723,10 @@ void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) case HB_P_MPUSHSTRLARGE: { - HB_SIZE ulSize = HB_PCODE_MKUINT24( &pCode[ 1 ] ); + HB_SIZE nSize = HB_PCODE_MKUINT24( &pCode[ 1 ] ); - hb_vmPushString( ( const char * ) ( pCode + 3 ), ulSize - 1 ); - pCode += 4 + ulSize; + hb_vmPushString( ( const char * ) ( pCode + 3 ), nSize - 1 ); + pCode += 4 + nSize; break; } @@ -3182,23 +3182,23 @@ static void hb_vmPlus( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pIte } else if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) ) { - HB_SIZE ulLen1 = pItem1->item.asString.length; - HB_SIZE ulLen2 = pItem2->item.asString.length; + HB_SIZE nLen1 = pItem1->item.asString.length; + HB_SIZE nLen2 = pItem2->item.asString.length; - if( ulLen2 ) + if( nLen2 ) { - if( ulLen1 ) + if( nLen1 ) { - if( ulLen1 < HB_SIZE_MAX - ulLen2 ) + if( nLen1 < HB_SIZE_MAX - nLen2 ) { 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 ); + hb_itemReSizeString( pItem1, nLen1 + nLen2 ); + hb_xmemcpy( pItem1->item.asString.value + nLen1, + pItem2->item.asString.value, nLen2 ); } else hb_errRT_BASE( EG_STROVERFLOW, 1209, NULL, "+", 2, pItem1, pItem2 ); @@ -3327,34 +3327,34 @@ static void hb_vmMinus( HB_ITEM_PTR pResult, HB_ITEM_PTR pItem1, HB_ITEM_PTR pIt } else if( HB_IS_STRING( pItem1 ) && HB_IS_STRING( pItem2 ) ) { - HB_SIZE ulLen1 = pItem1->item.asString.length; - HB_SIZE ulLen2 = pItem2->item.asString.length; + HB_SIZE nLen1 = pItem1->item.asString.length; + HB_SIZE nLen2 = pItem2->item.asString.length; - if( ulLen1 == 0 ) + if( nLen1 == 0 ) { hb_itemCopy( pResult, pItem2 ); pResult->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT ); } - else if( ulLen2 == 0 ) + else if( nLen2 == 0 ) { if( pResult != pItem1 ) hb_itemCopy( pResult, pItem1 ); pResult->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT ); } - else if( ulLen1 < HB_SIZE_MAX - ulLen2 ) + else if( nLen1 < HB_SIZE_MAX - nLen2 ) { 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 ); + hb_itemReSizeString( pItem1, nLen1 + nLen2 ); + while( nLen1 && pItem1->item.asString.value[ nLen1 - 1 ] == ' ' ) + nLen1--; + hb_xmemcpy( pItem1->item.asString.value + nLen1, + pItem2->item.asString.value, nLen2 ); + hb_xmemset( pItem1->item.asString.value + nLen1 + nLen2, ' ', + pItem1->item.asString.length - nLen1 - nLen2 ); } else hb_errRT_BASE( EG_STROVERFLOW, 1210, NULL, "-", 2, pItem1, pItem2 ); @@ -4642,10 +4642,10 @@ static void hb_vmEnumStart( int nVars, int nDescend ) } else if( HB_IS_HASH( pBase ) ) { - HB_SIZE ulLen = hb_hashLen( pBase ); + HB_SIZE nLen = hb_hashLen( pBase ); /* the index into a hash */ - pEnum->item.asEnum.offset = ( nDescend > 0 ) ? 1 : ulLen; - if( ulLen == 0 ) + pEnum->item.asEnum.offset = ( nDescend > 0 ) ? 1 : nLen; + if( nLen == 0 ) fStart = HB_FALSE; } else if( HB_IS_STRING( pBase ) ) @@ -5041,7 +5041,7 @@ static void hb_vmArrayPush( void ) HB_STACK_TLS_PRELOAD PHB_ITEM pIndex; PHB_ITEM pArray; - HB_SIZE ulIndex; + HB_SIZE nIndex; HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayPush()")); @@ -5064,11 +5064,11 @@ static void hb_vmArrayPush( void ) return; } else if( HB_IS_INTEGER( pIndex ) ) - ulIndex = ( HB_SIZE ) pIndex->item.asInteger.value; + nIndex = ( HB_SIZE ) pIndex->item.asInteger.value; else if( HB_IS_LONG( pIndex ) ) - ulIndex = ( HB_SIZE ) pIndex->item.asLong.value; + nIndex = ( HB_SIZE ) pIndex->item.asLong.value; else if( HB_IS_DOUBLE( pIndex ) ) - ulIndex = ( HB_SIZE ) pIndex->item.asDouble.value; + nIndex = ( HB_SIZE ) pIndex->item.asDouble.value; else { if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, NULL ) ) @@ -5095,9 +5095,9 @@ static void hb_vmArrayPush( void ) return; } - if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->nLen ) ) + if( HB_IS_VALID_INDEX( nIndex, pArray->item.asArray.value->nLen ) ) { - hb_itemCopy( pIndex, pArray->item.asArray.value->pItems + ulIndex - 1 ); + hb_itemCopy( pIndex, pArray->item.asArray.value->pItems + nIndex - 1 ); hb_itemMove( pArray, pIndex ); hb_stackDec(); } @@ -5124,7 +5124,7 @@ static void hb_vmArrayPushRef( void ) PHB_ITEM pIndex; PHB_ITEM pArray; PHB_ITEM pRefer; - HB_SIZE ulIndex; + HB_SIZE nIndex; HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayPushRef()")); @@ -5153,11 +5153,11 @@ static void hb_vmArrayPushRef( void ) return; } else if( HB_IS_INTEGER( pIndex ) ) - ulIndex = ( HB_SIZE ) pIndex->item.asInteger.value; + nIndex = ( HB_SIZE ) pIndex->item.asInteger.value; else if( HB_IS_LONG( pIndex ) ) - ulIndex = ( HB_SIZE ) pIndex->item.asLong.value; + nIndex = ( HB_SIZE ) pIndex->item.asLong.value; else if( HB_IS_DOUBLE( pIndex ) ) - ulIndex = ( HB_SIZE ) pIndex->item.asDouble.value; + nIndex = ( HB_SIZE ) pIndex->item.asDouble.value; else if( hb_objHasOperator( pArray, HB_OO_OP_ARRAYINDEX ) ) { /* create extended object index reference */ @@ -5187,10 +5187,10 @@ static void hb_vmArrayPushRef( void ) hb_stackPop(); return; } - else if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->nLen ) ) + else if( HB_IS_VALID_INDEX( nIndex, pArray->item.asArray.value->nLen ) ) { /* This function is safe for overwriting passed array, [druzus] */ - hb_arrayGetItemRef( pArray, ulIndex, pRefer ); + hb_arrayGetItemRef( pArray, nIndex, pRefer ); hb_stackDec(); } else if( !HB_IS_OBJECT( pArray ) && hb_objHasOperator( pArray, HB_OO_OP_ARRAYINDEX ) ) @@ -5224,7 +5224,7 @@ static void hb_vmArrayPop( void ) PHB_ITEM pValue; PHB_ITEM pIndex; PHB_ITEM pArray; - HB_SIZE ulIndex; + HB_SIZE nIndex; HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayPop()")); @@ -5257,11 +5257,11 @@ static void hb_vmArrayPop( void ) return; } else if( HB_IS_INTEGER( pIndex ) ) - ulIndex = ( HB_SIZE ) pIndex->item.asInteger.value; + nIndex = ( HB_SIZE ) pIndex->item.asInteger.value; else if( HB_IS_LONG( pIndex ) ) - ulIndex = ( HB_SIZE ) pIndex->item.asLong.value; + nIndex = ( HB_SIZE ) pIndex->item.asLong.value; else if( HB_IS_DOUBLE( pIndex ) ) - ulIndex = ( HB_SIZE ) pIndex->item.asDouble.value; + nIndex = ( HB_SIZE ) pIndex->item.asDouble.value; else { if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, pIndex, pValue ) ) @@ -5286,10 +5286,10 @@ static void hb_vmArrayPop( void ) return; } - if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->nLen ) ) + if( HB_IS_VALID_INDEX( nIndex, pArray->item.asArray.value->nLen ) ) { pValue->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT ); - hb_itemMoveRef( pArray->item.asArray.value->pItems + ulIndex - 1, pValue ); + hb_itemMoveRef( pArray->item.asArray.value->pItems + nIndex - 1, pValue ); hb_stackPop(); hb_stackPop(); hb_stackDec(); /* value was moved above hb_stackDec() is enough */ @@ -5319,32 +5319,32 @@ static void hb_vmArrayPop( void ) hb_errRT_BASE( EG_ARG, 1069, NULL, hb_langDGetErrorDesc( EG_ARRASSIGN ), 1, pIndex ); } -static void hb_vmArrayGen( HB_SIZE ulElements ) /* generates an ulElements Array and fills it from the stack values */ +static void hb_vmArrayGen( HB_SIZE nElements ) /* generates an nElements Array and fills it from the stack values */ { HB_STACK_TLS_PRELOAD PHB_ITEM pArray; - HB_SIZE ulPos; + HB_SIZE nPos; - HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayGen(%" HB_PFS "u)", ulElements)); + HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayGen(%" HB_PFS "u)", nElements)); /* create new array on HVM stack */ pArray = hb_stackAllocItem(); - hb_arrayNew( pArray, ulElements ); + hb_arrayNew( pArray, nElements ); - if( ulElements ) + if( nElements ) { /* move items from HVM stack to created array */ - for( ulPos = 0; ulPos < ulElements; ulPos++ ) + for( nPos = 0; nPos < nElements; nPos++ ) { - PHB_ITEM pValue = hb_stackItemFromTop( ( int ) ( ulPos - ulElements - 1 ) ); + PHB_ITEM pValue = hb_stackItemFromTop( ( int ) ( nPos - nElements - 1 ) ); pValue->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT ); - hb_itemMove( pArray->item.asArray.value->pItems + ulPos, pValue ); + hb_itemMove( pArray->item.asArray.value->pItems + nPos, pValue ); } /* move the new array to position of first parameter */ - hb_itemMove( hb_stackItemFromTop( -1 - ( int ) ulElements ), pArray ); + hb_itemMove( hb_stackItemFromTop( -1 - ( int ) nElements ), pArray ); /* decrease the stack counter - all items are NIL */ - hb_stackDecrease( ulElements ); + hb_stackDecrease( nElements ); } } @@ -5354,7 +5354,7 @@ static void hb_vmArrayGen( HB_SIZE ulElements ) /* generates an ulElements Array static void hb_vmArrayNew( HB_ITEM_PTR pArray, HB_USHORT uiDimension ) { HB_STACK_TLS_PRELOAD - HB_SIZE ulElements; + HB_SIZE nElements; HB_ITEM_PTR pDim; HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayNew(%p, %hu)", pArray, uiDimension)); @@ -5363,27 +5363,27 @@ static void hb_vmArrayNew( HB_ITEM_PTR pArray, HB_USHORT uiDimension ) /* use the proper type of number of elements */ if( HB_IS_INTEGER( pDim ) ) - ulElements = ( HB_SIZE ) pDim->item.asInteger.value; + nElements = ( HB_SIZE ) pDim->item.asInteger.value; else if( HB_IS_LONG( pDim ) ) - ulElements = ( HB_SIZE ) pDim->item.asLong.value; + nElements = ( HB_SIZE ) pDim->item.asLong.value; else if( HB_IS_DOUBLE( pDim ) ) - ulElements = ( HB_SIZE ) pDim->item.asDouble.value; + nElements = ( HB_SIZE ) 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; + nElements = 0; /* create an array */ - hb_arrayNew( pArray, ulElements ); + hb_arrayNew( pArray, nElements ); if( --uiDimension ) { /* call self recursively to create next dimensions */ - while( ulElements-- ) - hb_vmArrayNew( pArray->item.asArray.value->pItems + ulElements, uiDimension ); + while( nElements-- ) + hb_vmArrayNew( pArray->item.asArray.value->pItems + nElements, uiDimension ); } } @@ -5404,17 +5404,17 @@ static void hb_vmArrayDim( HB_USHORT uiDimensions ) /* generates an uiDimensions while( --uiDimensions ); } -static void hb_vmHashGen( HB_SIZE ulElements ) /* generates an ulElements Hash and fills it from the stack values */ +static void hb_vmHashGen( HB_SIZE nElements ) /* generates an nElements Hash and fills it from the stack values */ { HB_STACK_TLS_PRELOAD PHB_ITEM pHash, pKey, pVal; - HB_TRACE(HB_TR_DEBUG, ("hb_vmHashGen(%" HB_PFS "u)", ulElements)); + HB_TRACE(HB_TR_DEBUG, ("hb_vmHashGen(%" HB_PFS "u)", nElements)); /* create new hash item */ pHash = hb_hashNew( NULL ); - hb_hashPreallocate( pHash, ulElements ); - while( ulElements-- ) + hb_hashPreallocate( pHash, nElements ); + while( nElements-- ) { pKey = hb_stackItemFromTop( -2 ); pVal = hb_stackItemFromTop( -1 ); @@ -5442,7 +5442,7 @@ static void hb_vmHashGen( HB_SIZE ulElements ) /* generates an ulElements Hash a static void hb_vmMacroPushIndex( void ) { HB_STACK_TLS_PRELOAD - HB_SIZE ulIndexes; + HB_SIZE nIndexes; HB_TRACE(HB_TR_DEBUG, ("hb_vmMacroPushIndex()")); @@ -5450,15 +5450,15 @@ static void hb_vmMacroPushIndex( void ) * Now the top most element on the stack points to number of * additional indexes to generated array */ - ulIndexes = hb_itemGetNL( hb_stackItemFromTop( -1 ) ); + nIndexes = hb_itemGetNL( hb_stackItemFromTop( -1 ) ); /* TOFIX!!! */ hb_stackDec(); - if( ulIndexes > 1 ) + if( nIndexes > 1 ) { PHB_ITEM pIndexArray; - HB_SIZE ul = 1; + HB_SIZE n = 1; - hb_vmArrayGen( ulIndexes - 1 ); + hb_vmArrayGen( nIndexes - 1 ); pIndexArray = hb_itemNew( hb_stackItemFromTop( -1 ) ); hb_stackPop(); @@ -5473,13 +5473,13 @@ static void hb_vmMacroPushIndex( void ) /* RT error? */ if( hb_stackGetActionRequest() != 0 ) break; - hb_vmPush( hb_arrayGetItemPtr( pIndexArray, ul ) ); + hb_vmPush( hb_arrayGetItemPtr( pIndexArray, n ) ); } - while( ++ul < ulIndexes ); + while( ++n < nIndexes ); hb_itemRelease( pIndexArray ); } - else if( ulIndexes == 0 ) + else if( nIndexes == 0 ) hb_vmPushNil(); /* It will force RT error later in array push or pop */ } @@ -5605,16 +5605,16 @@ static void hb_vmPushAParams( void ) pArray = hb_stackItemFromTop( -1 ); if( HB_IS_ARRAY( pArray ) ) { - HB_SIZE ulLen = pArray->item.asArray.value->nLen, ul; + HB_SIZE nLen = pArray->item.asArray.value->nLen, ul; - if( ulLen ) + if( nLen ) { - for( ul = 1; ul < ulLen; ++ul ) + for( ul = 1; ul < nLen; ++ul ) hb_vmPush( pArray->item.asArray.value->pItems + ul ); pCount = hb_stackAllocItem(); hb_itemCopy( pCount, pArray->item.asArray.value->pItems ); hb_itemMove( pArray, pCount ); - hb_itemPutNS( pCount, ulLen ); + hb_itemPutNS( pCount, nLen ); } else hb_itemPutNL( pArray, 0 ); @@ -6779,24 +6779,24 @@ void hb_vmPushPointer( void * pPointer ) pItem->item.asPointer.single = HB_FALSE; } -void hb_vmPushString( const char * szText, HB_SIZE length ) +void hb_vmPushString( const char * szText, HB_SIZE nLength ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_vmPushString(%s, %" HB_PFS "u)", szText, length)); + HB_TRACE(HB_TR_DEBUG, ("hb_vmPushString(%s, %" HB_PFS "u)", szText, nLength)); - hb_itemPutCL( hb_stackAllocItem(), szText, length ); + hb_itemPutCL( hb_stackAllocItem(), szText, nLength ); } -void hb_vmPushStringPcode( const char * szText, HB_SIZE length ) +void hb_vmPushStringPcode( const char * szText, HB_SIZE nLength ) { HB_STACK_TLS_PRELOAD PHB_ITEM pItem = hb_stackAllocItem(); - HB_TRACE(HB_TR_DEBUG, ("hb_vmPushStringPcode(%s, %" HB_PFS "u)", szText, length)); + HB_TRACE(HB_TR_DEBUG, ("hb_vmPushStringPcode(%s, %" HB_PFS "u)", szText, nLength)); pItem->type = HB_IT_STRING; - pItem->item.asString.length = length; + pItem->item.asString.length = nLength; pItem->item.asString.allocated = 0; pItem->item.asString.value = ( char * ) szText; } @@ -6845,25 +6845,25 @@ void hb_vmPushEvalSym( void ) * * NOTE: pCode points to static memory */ -static void hb_vmPushBlock( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SIZE ulLen ) +static void hb_vmPushBlock( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SIZE nLen ) { HB_STACK_TLS_PRELOAD HB_USHORT uiLocals; PHB_ITEM pItem = hb_stackAllocItem(); - HB_TRACE(HB_TR_DEBUG, ("hb_vmPushBlock(%p,%p,%" HB_PFS "u)", pCode, pSymbols, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_vmPushBlock(%p,%p,%" HB_PFS "u)", pCode, pSymbols, nLen)); uiLocals = HB_PCODE_MKUSHORT( &pCode[ 2 ] ); - if( ulLen ) - ulLen -= uiLocals << 1; + if( nLen ) + nLen -= 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 ); + nLen ); pItem->type = HB_IT_BLOCK; /* store the number of expected parameters @@ -6882,19 +6882,19 @@ static void hb_vmPushBlock( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SIZE ul * * NOTE: pCode points to static memory */ -static void hb_vmPushBlockShort( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SIZE ulLen ) +static void hb_vmPushBlockShort( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SIZE nLen ) { HB_STACK_TLS_PRELOAD PHB_ITEM pItem = hb_stackAllocItem(); - HB_TRACE(HB_TR_DEBUG, ("hb_vmPushBlockShort(%p,%p,%" HB_PFS "u)", pCode, pSymbols, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_vmPushBlockShort(%p,%p,%" HB_PFS "u)", pCode, pSymbols, nLen)); pItem->item.asBlock.value = hb_codeblockNew( pCode, /* pcode buffer */ 0, /* number of referenced local variables */ NULL, /* table with referenced local variables */ pSymbols, - ulLen ); + nLen ); pItem->type = HB_IT_BLOCK; @@ -6915,14 +6915,14 @@ static void hb_vmPushBlockShort( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SI * * NOTE: pCode points to dynamically allocated memory */ -static void hb_vmPushMacroBlock( const HB_BYTE * pCode, HB_SIZE ulSize, HB_USHORT usParams ) +static void hb_vmPushMacroBlock( const HB_BYTE * pCode, HB_SIZE nSize, HB_USHORT usParams ) { HB_STACK_TLS_PRELOAD PHB_ITEM pItem = hb_stackAllocItem(); - HB_TRACE(HB_TR_DEBUG, ("hb_vmPushMacroBlock(%p,%" HB_PFS "u,%hu)", pCode, ulSize, usParams)); + HB_TRACE(HB_TR_DEBUG, ("hb_vmPushMacroBlock(%p,%" HB_PFS "u,%hu)", pCode, nSize, usParams)); - pItem->item.asBlock.value = hb_codeblockMacroNew( pCode, ulSize ); + pItem->item.asBlock.value = hb_codeblockMacroNew( pCode, nSize ); pItem->type = HB_IT_BLOCK; /* store the number of expected parameters @@ -7488,9 +7488,9 @@ static void hb_vmStaticsClear( void ) PHB_ITEM pStatics = HB_SYM_STATICSBASE( pSym ); if( pStatics ) { - HB_SIZE ulLen = hb_arrayLen( pStatics ), ul; + HB_SIZE nLen = hb_arrayLen( pStatics ), ul; - for( ul = 1; ul <= ulLen; ++ul ) + for( ul = 1; ul <= nLen; ++ul ) { PHB_ITEM pItem = hb_arrayGetItemPtr( pStatics, ul ); if( HB_IS_COMPLEX( pItem ) ) @@ -7524,7 +7524,7 @@ static void hb_vmStaticsRelease( void ) static HB_SIZE hb_vmStaticsCount( void ) { - HB_SIZE ulStatics = 0; + HB_SIZE nStatics = 0; if( hb_vmLockModuleSymbols() ) { @@ -7536,14 +7536,14 @@ static HB_SIZE hb_vmStaticsCount( void ) PHB_SYMB pSym = pLastSymbols->pModuleSymbols + pLastSymbols->uiStaticsOffset; PHB_ITEM pStatics = HB_SYM_STATICSBASE( pSym ); if( pStatics ) - ulStatics += hb_arrayLen( pStatics ); + nStatics += hb_arrayLen( pStatics ); } pLastSymbols = pLastSymbols->pNext; } hb_vmUnlockModuleSymbols(); } - return ulStatics; + return nStatics; } static PHB_ITEM hb_vmStaticsArray( void ) @@ -7553,11 +7553,11 @@ static PHB_ITEM hb_vmStaticsArray( void ) if( hb_vmLockModuleSymbols() ) { PHB_SYMBOLS pLastSymbols = s_pSymbols; - HB_SIZE ulOffset, ulCount; + HB_SIZE nOffset, nCount; - ulCount = hb_vmStaticsCount(); - pArray = hb_itemArrayNew( ulCount ); - ulOffset = 0; + nCount = hb_vmStaticsCount(); + pArray = hb_itemArrayNew( nCount ); + nOffset = 0; while( pLastSymbols ) { @@ -7567,10 +7567,10 @@ static PHB_ITEM hb_vmStaticsArray( void ) PHB_ITEM pStatics = HB_SYM_STATICSBASE( pSym ); if( pStatics ) { - HB_SIZE ulLen = hb_arrayLen( pStatics ), ul; + HB_SIZE nLen = hb_arrayLen( pStatics ), n; - for( ul = 1; ul <= ulLen; ++ul ) - hb_arraySet( pArray, ++ulOffset, hb_arrayGetItemPtr( pStatics, ul ) ); + for( n = 1; n <= nLen; ++n ) + hb_arraySet( pArray, ++nOffset, hb_arrayGetItemPtr( pStatics, n ) ); } } pLastSymbols = pLastSymbols->pNext; @@ -7828,19 +7828,19 @@ PHB_SYMBOLS hb_vmRegisterSymbols( PHB_SYMB pModuleSymbols, HB_USHORT uiSymbols, if( fClone ) { - HB_SIZE ulSymSize = ( HB_ULONG ) uiSymbols * sizeof( HB_SYMB ), ulSize; + HB_SIZE nSymSize = ( HB_ULONG ) uiSymbols * sizeof( HB_SYMB ), nSize; /* TOFIX !!! */ char * buffer; - ulSize = ulSymSize; + nSize = nSymSize; for( ui = 0; ui < uiSymbols; ui++ ) - ulSize += strlen( pModuleSymbols[ ui ].szName ) + 1; - buffer = ( char * ) memcpy( hb_xgrab( ulSize ), pModuleSymbols, ulSymSize ); + nSize += strlen( pModuleSymbols[ ui ].szName ) + 1; + buffer = ( char * ) memcpy( hb_xgrab( nSize ), pModuleSymbols, nSymSize ); pModuleSymbols = ( PHB_SYMB ) buffer; for( ui = 0; ui < uiSymbols; ui++ ) { - buffer += ulSymSize; - ulSymSize = strlen( pModuleSymbols[ ui ].szName ) + 1; - memcpy( buffer, pModuleSymbols[ ui ].szName, ulSymSize ); + buffer += nSymSize; + nSymSize = strlen( pModuleSymbols[ ui ].szName ) + 1; + memcpy( buffer, pModuleSymbols[ ui ].szName, nSymSize ); pModuleSymbols[ ui ].szName = buffer; } } @@ -10945,26 +10945,26 @@ void hb_xvmArrayDim( HB_USHORT uiDimensions ) hb_vmArrayDim( uiDimensions ); } -void hb_xvmArrayGen( HB_SIZE ulElements ) +void hb_xvmArrayGen( HB_SIZE nElements ) { - HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayGen(%" HB_PFS "u)", ulElements)); + HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayGen(%" HB_PFS "u)", nElements)); - hb_vmArrayGen( ulElements ); + hb_vmArrayGen( nElements ); } -void hb_xvmHashGen( HB_SIZE ulElements ) +void hb_xvmHashGen( HB_SIZE nElements ) { - HB_TRACE(HB_TR_DEBUG, ("hb_xvmHashGen(%" HB_PFS "u)", ulElements)); + HB_TRACE(HB_TR_DEBUG, ("hb_xvmHashGen(%" HB_PFS "u)", nElements)); - hb_vmHashGen( ulElements ); + hb_vmHashGen( nElements ); } -static void hb_vmArrayItemPush( HB_SIZE ulIndex ) +static void hb_vmArrayItemPush( HB_SIZE nIndex ) { HB_STACK_TLS_PRELOAD PHB_ITEM pArray; - HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayItemPush(%" HB_PFS "u)", ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayItemPush(%" HB_PFS "u)", nIndex)); pArray = hb_stackItemFromTop( -1 ); @@ -10972,24 +10972,24 @@ static void hb_vmArrayItemPush( HB_SIZE ulIndex ) { if( HB_IS_OBJECT( pArray ) && hb_objHasOperator( pArray, HB_OO_OP_ARRAYINDEX ) ) { - hb_vmPushNumInt( ulIndex ); + hb_vmPushNumInt( nIndex ); 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->nLen ) ) + if( HB_IS_VALID_INDEX( nIndex, pArray->item.asArray.value->nLen ) ) { PHB_ITEM pItem = hb_stackAllocItem(); - hb_itemCopy( pItem, pArray->item.asArray.value->pItems + ulIndex - 1 ); + hb_itemCopy( pItem, pArray->item.asArray.value->pItems + nIndex - 1 ); hb_itemMove( pArray, pItem ); hb_stackDec(); } else { - hb_vmPushNumInt( ulIndex ); + hb_vmPushNumInt( nIndex ); if( !HB_IS_OBJECT( pArray ) && hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, hb_stackItemFromTop( -1 ), NULL ) ) @@ -11007,7 +11007,7 @@ static void hb_vmArrayItemPush( HB_SIZE ulIndex ) { PHB_ITEM pValue, pIndex; - hb_vmPushNumInt( ulIndex ); + hb_vmPushNumInt( nIndex ); pIndex = hb_stackItemFromTop( -1 ); pValue = hb_hashGetItemPtr( pArray, pIndex, HB_HASH_AUTOADD_ACCESS ); @@ -11025,7 +11025,7 @@ static void hb_vmArrayItemPush( HB_SIZE ulIndex ) } else { - hb_vmPushNumInt( ulIndex ); + hb_vmPushNumInt( nIndex ); if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, hb_stackItemFromTop( -1 ), NULL ) ) hb_stackPop(); @@ -11034,13 +11034,13 @@ static void hb_vmArrayItemPush( HB_SIZE ulIndex ) } } -static void hb_vmArrayItemPop( HB_SIZE ulIndex ) +static void hb_vmArrayItemPop( HB_SIZE nIndex ) { HB_STACK_TLS_PRELOAD PHB_ITEM pValue; PHB_ITEM pArray; - HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayItemPop(%" HB_PFS "u)", ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayItemPop(%" HB_PFS "u)", nIndex)); pValue = hb_stackItemFromTop( -2 ); pArray = hb_stackItemFromTop( -1 ); @@ -11052,7 +11052,7 @@ static void hb_vmArrayItemPop( HB_SIZE ulIndex ) { if( HB_IS_OBJECT( pArray ) && hb_objHasOperator( pArray, HB_OO_OP_ARRAYINDEX ) ) { - hb_vmPushNumInt( ulIndex ); + hb_vmPushNumInt( nIndex ); hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, hb_stackItemFromTop( -1 ), pValue ); hb_stackPop(); @@ -11061,16 +11061,16 @@ static void hb_vmArrayItemPop( HB_SIZE ulIndex ) return; } - if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->nLen ) ) + if( HB_IS_VALID_INDEX( nIndex, pArray->item.asArray.value->nLen ) ) { pValue->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT ); - hb_itemMoveRef( pArray->item.asArray.value->pItems + ulIndex - 1, pValue ); + hb_itemMoveRef( pArray->item.asArray.value->pItems + nIndex - 1, pValue ); hb_stackPop(); hb_stackDec(); /* value was moved above hb_stackDec() is enough */ } else { - hb_vmPushNumInt( ulIndex ); + hb_vmPushNumInt( nIndex ); if( !HB_IS_OBJECT( pArray ) && hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, hb_stackItemFromTop( -1 ), pValue ) ) @@ -11092,7 +11092,7 @@ static void hb_vmArrayItemPop( HB_SIZE ulIndex ) { PHB_ITEM pDest; - hb_vmPushNumInt( ulIndex ); + hb_vmPushNumInt( nIndex ); pDest = hb_hashGetItemPtr( pArray, hb_stackItemFromTop( -1 ), HB_HASH_AUTOADD_ASSIGN ); if( pDest ) @@ -11115,7 +11115,7 @@ static void hb_vmArrayItemPop( HB_SIZE ulIndex ) } else { - hb_vmPushNumInt( ulIndex ); + hb_vmPushNumInt( nIndex ); if( hb_objOperatorCall( HB_OO_OP_ARRAYINDEX, pArray, pArray, hb_stackItemFromTop( -1 ), pValue ) ) { @@ -11152,13 +11152,13 @@ HB_BOOL hb_xvmArrayPushRef( void ) HB_XVM_RETURN } -HB_BOOL hb_xvmArrayItemPush( HB_SIZE ulIndex ) +HB_BOOL hb_xvmArrayItemPush( HB_SIZE nIndex ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayItemPush(%" HB_PFS "u)", ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayItemPush(%" HB_PFS "u)", nIndex)); - hb_vmArrayItemPush( ulIndex ); + hb_vmArrayItemPush( nIndex ); HB_XVM_RETURN } @@ -11174,13 +11174,13 @@ HB_BOOL hb_xvmArrayPop( void ) HB_XVM_RETURN } -HB_BOOL hb_xvmArrayItemPop( HB_SIZE ulIndex ) +HB_BOOL hb_xvmArrayItemPop( HB_SIZE nIndex ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayItemPop(%" HB_PFS "u)", ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayItemPop(%" HB_PFS "u)", nIndex)); - hb_vmArrayItemPop( ulIndex ); + hb_vmArrayItemPop( nIndex ); HB_XVM_RETURN } @@ -11208,15 +11208,15 @@ void hb_xvmPushLongLong( HB_LONGLONG llNumber ) } #endif -void hb_xvmPushStringHidden( int iMethod, const char * szText, HB_SIZE ulSize ) +void hb_xvmPushStringHidden( int iMethod, const char * szText, HB_SIZE nSize ) { HB_STACK_TLS_PRELOAD char * szString; - HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushStringHidden(%d, %s, %" HB_PFS "u)", iMethod, szText, ulSize)); + HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushStringHidden(%d, %s, %" HB_PFS "u)", iMethod, szText, nSize)); - szString = hb_compDecodeString( iMethod, szText, &ulSize ); - hb_itemPutCLPtr( hb_stackAllocItem(), szString, ulSize ); + szString = hb_compDecodeString( iMethod, szText, &nSize ); + hb_itemPutCLPtr( hb_stackAllocItem(), szString, nSize ); } void hb_xvmLocalName( HB_USHORT uiLocal, const char * szLocalName ) diff --git a/harbour/src/vm/macro.c b/harbour/src/vm/macro.c index 31ab444338..6f7681e2b1 100644 --- a/harbour/src/vm/macro.c +++ b/harbour/src/vm/macro.c @@ -254,29 +254,29 @@ static void hb_macroSyntaxError( HB_MACRO_PTR pMacro ) * PRIVATE &a&b //this will cause syntax error '&' * */ -static char * hb_macroTextSubst( const char * szString, HB_SIZE * pulStringLen ) +static char * hb_macroTextSubst( const char * szString, HB_SIZE * pnStringLen ) { char * szResult; - HB_SIZE ulResStrLen; - HB_SIZE ulResBufLen; - HB_SIZE ulCharsLeft; + HB_SIZE nResStrLen; + HB_SIZE nResBufLen; + HB_SIZE nCharsLeft; char * pHead; char * pTail; - HB_TRACE(HB_TR_DEBUG, ("hb_macroTextSubst(%s, %" HB_PFS "u)", szString, *pulStringLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_macroTextSubst(%s, %" HB_PFS "u)", szString, *pnStringLen)); - pHead = ( char * ) memchr( szString, '&', *pulStringLen ); + pHead = ( char * ) memchr( szString, '&', *pnStringLen ); if( pHead == NULL ) return ( char * ) szString; /* no more processing is required */ /* initial length of the string and the result buffer (it can contain null bytes) */ - ulResBufLen = ulResStrLen = *pulStringLen; + nResBufLen = nResStrLen = *pnStringLen; /* initial buffer for return value */ - szResult = ( char * ) hb_xgrab( ulResBufLen + 1 ); + szResult = ( char * ) hb_xgrab( nResBufLen + 1 ); /* copy the input string with trailing zero byte */ - memcpy( szResult, szString, ulResStrLen + 1 ); + memcpy( szResult, szString, nResStrLen + 1 ); /* switch the pointer so it will point into the result buffer */ pHead = szResult + ( pHead - szString ); @@ -300,7 +300,7 @@ static char * hb_macroTextSubst( const char * szString, HB_SIZE * pulStringLen ) * length of identifiers (HB_SYMBOL_NAME_LEN) - only the max allowed * are used for name lookup however the whole string is replaced */ - HB_SIZE ulNameLen = 1; + HB_SIZE nNameLen = 1; char * pName = pHead; while( *++pHead && ( *pHead == '_' || @@ -308,17 +308,17 @@ static char * hb_macroTextSubst( const char * szString, HB_SIZE * pulStringLen ) ( *pHead >= 'a' && *pHead <= 'z' ) || ( *pHead >= '0' && *pHead <= '9' ) ) ) { - ++ulNameLen; + ++nNameLen; } /* pHead points now at the character that terminated a variable name */ /* NOTE: '_' is invalid variable name */ - if( ulNameLen > 1 || *pName != '_' ) + if( nNameLen > 1 || *pName != '_' ) { /* this is not the "&_" string */ char * szValPtr; - HB_SIZE ulValLen; + HB_SIZE nValLen; /* Get a pointer to the string value stored in this variable * or NULL if variable doesn't exist or doesn't contain a string @@ -326,47 +326,47 @@ static char * hb_macroTextSubst( const char * szString, HB_SIZE * pulStringLen ) * 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 ); + nValLen = nNameLen; /* the length of name */ + szValPtr = hb_memvarGetStrValuePtr( pName, &nValLen ); if( szValPtr ) { if( *pHead == '.' ) { /* we have stopped at the macro terminator '.' - skip it */ ++pHead; - ++ulNameLen; + ++nNameLen; } - ++ulNameLen; /* count also the '&' character */ + ++nNameLen; /* count also the '&' character */ /* number of characters left on the right side of a variable name */ - ulCharsLeft = ulResStrLen - ( pHead - szResult ); + nCharsLeft = nResStrLen - ( 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 + * 'nResStrLen' stores the current length of a string in the buffer + * 'nResBufLen' stores the length of the buffer */ - if( ulValLen > ulNameLen ) + if( nValLen > nNameLen ) { - ulResStrLen += ( ulValLen - ulNameLen ); - if( ulResStrLen > ulResBufLen ) + nResStrLen += ( nValLen - nNameLen ); + if( nResStrLen > nResBufLen ) { - HB_SIZE ulHead = pHead - szResult; - HB_SIZE ulTail = pTail - szResult; - ulResBufLen = ulResStrLen; - szResult = ( char * ) hb_xrealloc( szResult, ulResBufLen + 1 ); - pHead = szResult + ulHead; - pTail = szResult + ulTail; + HB_SIZE nHead = pHead - szResult; + HB_SIZE nTail = pTail - szResult; + nResBufLen = nResStrLen; + szResult = ( char * ) hb_xrealloc( szResult, nResBufLen + 1 ); + pHead = szResult + nHead; + pTail = szResult + nTail; } } else - ulResStrLen -= ( ulNameLen - ulValLen ); + nResStrLen -= ( nNameLen - nValLen ); /* move bytes located on the right side of a variable name */ - memmove( pTail + ulValLen, pHead, ulCharsLeft + 1 ); + memmove( pTail + nValLen, pHead, nCharsLeft + 1 ); /* copy substituted value */ - memcpy( pTail, szValPtr, ulValLen ); + memcpy( pTail, szValPtr, nValLen ); /* restart scanning from the beginning of replaced string */ /* NOTE: This causes that the following code: * a := '&a' @@ -378,20 +378,20 @@ static char * hb_macroTextSubst( const char * szString, HB_SIZE * pulStringLen ) } } } - ulCharsLeft = ulResStrLen - ( pHead - szResult ); + nCharsLeft = nResStrLen - ( pHead - szResult ); } - while( ulCharsLeft && ( pHead = ( char * ) memchr( pHead, '&', ulCharsLeft ) ) != NULL ); + while( nCharsLeft && ( pHead = ( char * ) memchr( pHead, '&', nCharsLeft ) ) != NULL ); - if( ulResStrLen < ulResBufLen ) + if( nResStrLen < nResBufLen ) { /* result string is shorter then allocated buffer - * cut it to a required length */ - szResult = ( char * ) hb_xrealloc( szResult, ulResStrLen + 1 ); + szResult = ( char * ) hb_xrealloc( szResult, nResStrLen + 1 ); } - szResult[ ulResStrLen ] = 0; /* place terminating null character */ + szResult[ nResStrLen ] = 0; /* place terminating null character */ /* return a length of result string */ - *pulStringLen = ulResStrLen; + *pnStringLen = nResStrLen; return szResult; /* a new memory buffer was allocated */ } @@ -594,8 +594,8 @@ static void hb_macroUseAliased( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, int iFlag, { /* grab memory for "alias->var" */ - HB_SIZE ulLen = pAlias->item.asString.length + pVar->item.asString.length + 2; - char * szString = ( char * ) hb_xgrab( ulLen + 1 ); + HB_SIZE nLen = pAlias->item.asString.length + pVar->item.asString.length + 2; + char * szString = ( char * ) hb_xgrab( nLen + 1 ); HB_MACRO struMacro; int iStatus; @@ -603,7 +603,7 @@ static void hb_macroUseAliased( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, int iFlag, 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'; + szString[ nLen ] = '\0'; struMacro.mode = HB_MODE_MACRO; struMacro.supported = (iSupported & HB_SM_RT_MACRO) ? hb_macroFlags() : iSupported; @@ -611,7 +611,7 @@ static void hb_macroUseAliased( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, int iFlag, struMacro.uiNameLen = HB_SYMBOL_NAME_LEN; struMacro.status = HB_MACRO_CONT; struMacro.string = szString; - struMacro.length = ulLen; + struMacro.length = nLen; iStatus = hb_macroParse( &struMacro ); @@ -624,7 +624,7 @@ static void hb_macroUseAliased( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, int iFlag, } else { - hb_vmPushString( szString, ulLen ); + hb_vmPushString( szString, nLen ); hb_macroSyntaxError( &struMacro ); } @@ -690,78 +690,78 @@ void hb_macroPushAliasedValue( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, int flags ) * new string if a valid macro text substitution was found (and sets * pbNewString to TRUE) */ -char * hb_macroExpandString( const char *szString, HB_SIZE ulLength, HB_BOOL *pfNewString ) +char * hb_macroExpandString( const char *szString, HB_SIZE nLength, HB_BOOL *pfNewString ) { char *szResultString; - HB_TRACE(HB_TR_DEBUG, ("hb_macroExpandString(%s,%" HB_PFS "u,%p)", szString, ulLength, pfNewString)); + HB_TRACE(HB_TR_DEBUG, ("hb_macroExpandString(%s,%" HB_PFS "u,%p)", szString, nLength, pfNewString)); if( szString ) - szResultString = hb_macroTextSubst( szString, &ulLength ); + szResultString = hb_macroTextSubst( szString, &nLength ); else szResultString = ( char * ) szString; *pfNewString = ( szString != szResultString ); return szResultString; } -char * hb_macroTextSymbol( const char *szString, HB_SIZE ulLength, HB_BOOL *pfNewString ) +char * hb_macroTextSymbol( const char *szString, HB_SIZE nLength, HB_BOOL *pfNewString ) { char *szResult = NULL; - HB_TRACE(HB_TR_DEBUG, ("hb_macroTextSymbol(%s,%" HB_PFS "u,%p)", szString, ulLength, pfNewString)); + HB_TRACE(HB_TR_DEBUG, ("hb_macroTextSymbol(%s,%" HB_PFS "u,%p)", szString, nLength, pfNewString)); if( szString ) { - HB_SIZE ulLen = 0; + HB_SIZE nLen = 0; - szResult = hb_macroTextSubst( szString, &ulLength ); + szResult = hb_macroTextSubst( szString, &nLength ); - while( ulLength && ( szResult[ 0 ] == ' ' || szResult[ 0 ] == '\t' ) ) + while( nLength && ( szResult[ 0 ] == ' ' || szResult[ 0 ] == '\t' ) ) { ++szResult; ++szString; - --ulLength; + --nLength; } - while( ulLength && ( szResult[ ulLength - 1 ] == ' ' || - szResult[ ulLength - 1 ] == '\t' ) ) - --ulLength; + while( nLength && ( szResult[ nLength - 1 ] == ' ' || + szResult[ nLength - 1 ] == '\t' ) ) + --nLength; /* NOTE: This uses _a-zA-Z0-9 pattern to check for a valid name * "_" is not valid macro string */ - while( ulLen < ulLength ) + while( nLen < nLength ) { - char c = szResult[ ulLen ]; + char c = szResult[ nLen ]; if( c >= 'a' && c <= 'z' ) { if( szResult == szString ) { - szResult = ( char * ) hb_xgrab( ulLength + 1 ); - memcpy( szResult, szString, ulLength ); - szResult[ ulLength ] = '\0'; + szResult = ( char * ) hb_xgrab( nLength + 1 ); + memcpy( szResult, szString, nLength ); + szResult[ nLength ] = '\0'; } - szResult[ ulLen ] = c - ( 'a' - 'A' ); + szResult[ nLen ] = c - ( 'a' - 'A' ); } else if( ! ( c == '_' || ( c >= 'A' && c <= 'Z' ) || - ( ulLen && ( c >= '0' && c <= '9' ) ) ) ) + ( nLen && ( c >= '0' && c <= '9' ) ) ) ) { break; } - ++ulLen; + ++nLen; } - if( ulLen == ulLength && ulLen > ( HB_SIZE ) ( szResult[ 0 ] == '_' ? 1 : 0 ) ) + if( nLen == nLength && nLen > ( HB_SIZE ) ( szResult[ 0 ] == '_' ? 1 : 0 ) ) { - if( ulLen > HB_SYMBOL_NAME_LEN ) - ulLen = HB_SYMBOL_NAME_LEN; - if( szResult[ ulLen ] ) + if( nLen > HB_SYMBOL_NAME_LEN ) + nLen = HB_SYMBOL_NAME_LEN; + if( szResult[ nLen ] ) { if( szResult == szString ) { - szResult = ( char * ) hb_xgrab( ulLen + 1 ); - memcpy( szResult, szString, ulLen ); + szResult = ( char * ) hb_xgrab( nLen + 1 ); + memcpy( szResult, szString, nLen ); } - szResult[ ulLen ] = '\0'; + szResult[ nLen ] = '\0'; } } else @@ -897,15 +897,15 @@ void hb_macroTextValue( HB_ITEM_PTR pItem ) if( hb_macroCheckParam( pItem ) ) { char * szString; - HB_SIZE ulLength = pItem->item.asString.length; + HB_SIZE nLength = pItem->item.asString.length; - szString = hb_macroTextSubst( pItem->item.asString.value, &ulLength ); + szString = hb_macroTextSubst( pItem->item.asString.value, &nLength ); if( szString != pItem->item.asString.value ) { /* replace the old value on the eval stack with the new one */ - hb_itemPutCLPtr( pItem, szString, ulLength ); + hb_itemPutCLPtr( pItem, szString, nLength ); } /* * else @@ -1089,11 +1089,11 @@ int hb_macroLocalVarGetPos( const char * szVarName, HB_COMP_DECL ) return 0; } -HB_BOOL hb_macroIsValidMacroText( const char * szText, HB_SIZE ulLen ) +HB_BOOL hb_macroIsValidMacroText( const char * szText, HB_SIZE nLen ) { - if( ulLen ) + if( nLen ) { - while( --ulLen ) + while( --nLen ) { if( *szText++ == '&' ) { @@ -1156,20 +1156,20 @@ HB_SIZE hb_macroGenJumpTrue( HB_ISIZ lOffset, HB_COMP_DECL ) return HB_PCODE_DATA->lPCodePos - 3; } -void hb_macroGenJumpThere( HB_SIZE ulFrom, HB_SIZE ulTo, HB_COMP_DECL ) +void hb_macroGenJumpThere( HB_SIZE nFrom, HB_SIZE nTo, HB_COMP_DECL ) { HB_BYTE * pCode = HB_PCODE_DATA->pCode; - HB_ISIZ lOffset = ulTo - ulFrom + 1; + HB_ISIZ lOffset = nTo - nFrom + 1; if( HB_LIM_INT24( lOffset ) ) - HB_PUT_LE_UINT24( &pCode[ ulFrom ], lOffset ); + HB_PUT_LE_UINT24( &pCode[ nFrom ], lOffset ); else hb_macroError( HB_MACRO_TOO_COMPLEX, HB_COMP_PARAM ); } -void hb_macroGenJumpHere( HB_SIZE ulOffset, HB_COMP_DECL ) +void hb_macroGenJumpHere( HB_SIZE nOffset, HB_COMP_DECL ) { - hb_macroGenJumpThere( ulOffset, HB_PCODE_DATA->lPCodePos, HB_COMP_PARAM ); + hb_macroGenJumpThere( nOffset, HB_PCODE_DATA->lPCodePos, HB_COMP_PARAM ); } /* @@ -1542,15 +1542,15 @@ void hb_macroGenPushFunRef( const char * szFunName, HB_COMP_DECL ) } /* generates the pcode to push a string on the virtual machine stack */ -void hb_macroGenPushString( const char * szText, HB_SIZE ulStrLen, HB_COMP_DECL ) +void hb_macroGenPushString( const char * szText, HB_SIZE nStrLen, HB_COMP_DECL ) { - if( ulStrLen <= UINT24_MAX ) + if( nStrLen <= UINT24_MAX ) { - if( ulStrLen <= USHRT_MAX ) - hb_macroGenPCode3( HB_P_MPUSHSTR, HB_LOBYTE( ulStrLen ), HB_HIBYTE( ulStrLen ), HB_COMP_PARAM ); + if( nStrLen <= USHRT_MAX ) + hb_macroGenPCode3( HB_P_MPUSHSTR, HB_LOBYTE( nStrLen ), HB_HIBYTE( nStrLen ), HB_COMP_PARAM ); else - hb_macroGenPCode4( HB_P_MPUSHSTRLARGE, HB_LOBYTE( ulStrLen ), HB_HIBYTE( ulStrLen ), HB_ULBYTE( ulStrLen ), HB_COMP_PARAM ); - hb_macroGenPCodeN( ( HB_BYTE * ) szText, ulStrLen, HB_COMP_PARAM ); + hb_macroGenPCode4( HB_P_MPUSHSTRLARGE, HB_LOBYTE( nStrLen ), HB_HIBYTE( nStrLen ), HB_ULBYTE( nStrLen ), HB_COMP_PARAM ); + hb_macroGenPCodeN( ( HB_BYTE * ) szText, nStrLen, HB_COMP_PARAM ); } else hb_macroError( HB_MACRO_TOO_COMPLEX, HB_COMP_PARAM ); @@ -1602,19 +1602,19 @@ void hb_macroGenPCode4( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_BYTE byt pFunc->pCode[ pFunc->lPCodePos++ ] = byte4; } -void hb_macroGenPCodeN( HB_BYTE * pBuffer, HB_SIZE ulSize, HB_COMP_DECL ) +void hb_macroGenPCodeN( HB_BYTE * pBuffer, HB_SIZE nSize, HB_COMP_DECL ) { HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA; - if( pFunc->lPCodePos + ulSize > pFunc->lPCodeSize ) + if( pFunc->lPCodePos + nSize > pFunc->lPCodeSize ) { /* not enough free space in pcode buffer - increase it */ - pFunc->lPCodeSize += ( ( ( ulSize / HB_PCODE_SIZE ) + 1 ) * HB_PCODE_SIZE ); + pFunc->lPCodeSize += ( ( ( nSize / HB_PCODE_SIZE ) + 1 ) * HB_PCODE_SIZE ); pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize ); } - memcpy( pFunc->pCode + pFunc->lPCodePos, pBuffer, ulSize ); - pFunc->lPCodePos += ulSize; + memcpy( pFunc->pCode + pFunc->lPCodePos, pBuffer, nSize ); + pFunc->lPCodePos += nSize; } /* ************************************************************************* */ @@ -1651,8 +1651,8 @@ void hb_macroCodeBlockStart( HB_COMP_DECL ) void hb_macroCodeBlockEnd( HB_COMP_DECL ) { HB_PCODE_INFO_PTR pCodeblock; /* pointer to the current codeblock */ - HB_SIZE ulSize; - HB_USHORT wParms = 0; /* number of codeblock parameters */ + HB_SIZE nSize; + HB_USHORT usParms = 0; /* number of codeblock parameters */ HB_CBVAR_PTR pVar; HB_TRACE(HB_TR_DEBUG, ("hb_macroCodeBlockEnd(%p)", HB_COMP_PARAM)); @@ -1674,26 +1674,26 @@ void hb_macroCodeBlockEnd( HB_COMP_DECL ) while( pVar ) { pVar = pVar->pNext; - ++wParms; + ++usParms; } /* NOTE: 6 = HB_P_MPUSHBLOCK + HB_USHORT( size ) + HB_USHORT( wParams ) + _ENDBLOCK * runtime compiled codeblock cannot reference local variables defined in a * function */ - ulSize = pCodeblock->lPCodePos + 6; + nSize = 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 ); + if( nSize <= USHRT_MAX ) + hb_macroGenPCode3( HB_P_MPUSHBLOCK, HB_LOBYTE( nSize ), HB_HIBYTE( nSize ), HB_COMP_PARAM ); else { - ++ulSize; - hb_macroGenPCode4( HB_P_MPUSHBLOCKLARGE, HB_LOBYTE( ulSize ), HB_HIBYTE( ulSize ), HB_ULBYTE( ulSize ), HB_COMP_PARAM ); + ++nSize; + hb_macroGenPCode4( HB_P_MPUSHBLOCKLARGE, HB_LOBYTE( nSize ), HB_HIBYTE( nSize ), HB_ULBYTE( nSize ), HB_COMP_PARAM ); } - hb_macroGenPCode2( HB_LOBYTE( wParms ), HB_HIBYTE( wParms ), HB_COMP_PARAM ); + hb_macroGenPCode2( HB_LOBYTE( usParms ), HB_HIBYTE( usParms ), HB_COMP_PARAM ); /* copy a codeblock pcode buffer */ hb_macroGenPCodeN( pCodeblock->pCode, pCodeblock->lPCodePos, HB_COMP_PARAM );