void hb_memvarGetRefer( PHB_ITEM pItem, PHB_SYMB pMemvarSymb ) { PHB_DYNS pDyn; HB_TRACE( HB_TR_DEBUG, ( "hb_memvarGetRefer(%p, %p)", pItem, pMemvarSymb ) ); pDyn = ( PHB_DYNS ) pMemvarSymb->pDynSym; if( pDyn ) { PHB_ITEM pMemvar; pMemvar = hb_dynsymGetMemvar( pDyn ); HB_TRACE( HB_TR_INFO, ( "Memvar item (%p)(%s) referenced", pMemvar, pMemvarSymb->szName ) ); if( pMemvar ) { if( HB_IS_BYREF( pMemvar ) && ! HB_IS_ENUM( pMemvar ) ) hb_itemCopy( pItem, pMemvar ); else { /* value is already created */ pItem->type = HB_IT_BYREF | HB_IT_MEMVAR; pItem->item.asMemvar.value = pMemvar; hb_xRefInc( pMemvar ); } } else { /* Generate an error with retry possibility * (user created error handler can make this variable accessible) */ PHB_ITEM pError; pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, 1003, NULL, pMemvarSymb->szName, 0, EF_CANRETRY ); while( hb_errLaunch( pError ) == E_RETRY ) { pMemvar = hb_dynsymGetMemvar( pDyn ); if( pMemvar ) { if( HB_IS_BYREF( pMemvar ) && ! HB_IS_ENUM( pMemvar ) ) hb_itemCopy( pItem, pMemvar ); else { /* value is already created */ pItem->type = HB_IT_BYREF | HB_IT_MEMVAR; pItem->item.asMemvar.value = pMemvar; hb_xRefInc( pMemvar ); } break; } } hb_errRelease( pError ); } } else hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL ); }
/* * Detach local variable (swap current value with a memvar handle) */ PHB_ITEM hb_memvarDetachLocal( PHB_ITEM pLocal ) { HB_TRACE( HB_TR_DEBUG, ( "hb_memvarDetachLocal(%p)", pLocal ) ); if( HB_IS_BYREF( pLocal ) ) { do { if( HB_IS_MEMVAR( pLocal ) || HB_IS_EXTREF( pLocal ) ) break; else if( HB_IS_ENUM( pLocal ) ) { if( ! pLocal->item.asEnum.valuePtr ) { PHB_ITEM pBase = HB_IS_BYREF( pLocal->item.asEnum.basePtr ) ? hb_itemUnRef( pLocal->item.asEnum.basePtr ) : pLocal->item.asEnum.basePtr; if( HB_IS_ARRAY( pBase ) ) { PHB_ITEM pItem = hb_itemNew( NULL ); hb_arrayGetItemRef( pBase, pLocal->item.asEnum.offset, pItem ); pLocal->item.asEnum.valuePtr = pItem; pLocal = pItem; break; } } } else if( pLocal->item.asRefer.value >= 0 && pLocal->item.asRefer.offset == 0 ) break; pLocal = hb_itemUnRefOnce( pLocal ); } while( HB_IS_BYREF( pLocal ) ); } /* Change the value only if this variable is not referenced * by another codeblock yet. * In this case we have to copy the current value to a global memory * pool so it can be shared by codeblocks */ if( ! HB_IS_MEMVAR( pLocal ) ) { PHB_ITEM pMemvar = hb_memvarValueNew(); hb_itemRawCpy( pMemvar, pLocal ); pMemvar->type &= ~HB_IT_DEFAULT; pLocal->type = HB_IT_BYREF | HB_IT_MEMVAR; pLocal->item.asMemvar.value = pMemvar; } return pLocal; }
/* Mark a passed item as used so it will be not released by the GC */ void hb_gcItemRef( PHB_ITEM pItem ) { while( HB_IS_BYREF( pItem ) ) { if( HB_IS_ENUM( pItem ) ) return; else if( HB_IS_EXTREF( pItem ) ) { pItem->item.asExtRef.func->mark( pItem->item.asExtRef.value ); return; } else if( ! HB_IS_MEMVAR( pItem ) && pItem->item.asRefer.offset == 0 && pItem->item.asRefer.value >= 0 ) { /* array item reference */ PHB_GARBAGE pAlloc = HB_GC_PTR( pItem->item.asRefer.BasePtr.array ); if( ( pAlloc->used & ~HB_GC_DELETE ) == s_uUsedFlag ) { /* mark this array as used */ pAlloc->used ^= HB_GC_USED_FLAG; /* mark also all array elements */ pAlloc->pFuncs->mark( HB_BLOCK_PTR( pAlloc ) ); } return; } pItem = hb_itemUnRefOnce( pItem ); } if( HB_IS_ARRAY( pItem ) ) { PHB_GARBAGE pAlloc = HB_GC_PTR( pItem->item.asArray.value ); /* Check this array only if it was not checked yet */ if( ( pAlloc->used & ~HB_GC_DELETE ) == s_uUsedFlag ) { /* mark this array as used so it will be no re-checked from * other references */ pAlloc->used ^= HB_GC_USED_FLAG; /* mark also all array elements */ pAlloc->pFuncs->mark( HB_BLOCK_PTR( pAlloc ) ); } } else if( HB_IS_HASH( pItem ) ) { PHB_GARBAGE pAlloc = HB_GC_PTR( pItem->item.asHash.value ); /* Check this hash table only if it was not checked yet */ if( ( pAlloc->used & ~HB_GC_DELETE ) == s_uUsedFlag ) { /* mark this hash table as used */ pAlloc->used ^= HB_GC_USED_FLAG; /* mark also all hash elements */ pAlloc->pFuncs->mark( HB_BLOCK_PTR( pAlloc ) ); } } else if( HB_IS_BLOCK( pItem ) ) { PHB_GARBAGE pAlloc = HB_GC_PTR( pItem->item.asBlock.value ); if( ( pAlloc->used & ~HB_GC_DELETE ) == s_uUsedFlag ) { /* mark this codeblock as used */ pAlloc->used ^= HB_GC_USED_FLAG; /* mark as used all detached variables in a codeblock */ pAlloc->pFuncs->mark( HB_BLOCK_PTR( pAlloc ) ); } } else if( HB_IS_POINTER( pItem ) ) { if( pItem->item.asPointer.collect ) { PHB_GARBAGE pAlloc = HB_GC_PTR( pItem->item.asPointer.value ); if( ( pAlloc->used & ~HB_GC_DELETE ) == s_uUsedFlag ) { /* mark this memory block as used */ pAlloc->used ^= HB_GC_USED_FLAG; /* mark also all internal user blocks attached to this block */ pAlloc->pFuncs->mark( HB_BLOCK_PTR( pAlloc ) ); } } } /* all other data types don't need the GC */ }