void hb_taskDestroyMutex( void ** pMutexPtr )
{
PHB_TASKMTX pMutex = ( PHB_TASKMTX ) *pMutexPtr;
if( pMutex )
{
PHB_TASKMTX * pMutexLst = &s_mutexList;
while( *pMutexLst )
{
if( *pMutexLst == pMutex )
{
*pMutexLst = pMutex->next;
if( pMutex->count )
hb_errInternal( HB_EI_ERRUNRECOV, "TaskDestroyMutex: locked", NULL, NULL );
else if( pMutex->lockers )
hb_errInternal( HB_EI_ERRUNRECOV, "TaskDestroyMutex: lockers", NULL, NULL );
hb_xfree( pMutex );
return;
}
pMutexLst = &( *pMutexLst )->next;
}
hb_errInternal( HB_EI_ERRUNRECOV, "TaskDestroyMutex: not a mutex", NULL, NULL );
}
}
void hb_xfree( void * pMem ) /* frees fixed memory */
{
if( pMem )
{
#ifdef HB_FM_STATISTICS
PHB_MEMINFO pMemBlock = ( PHB_MEMINFO ) ( ( HB_BYTE * ) pMem - HB_MEMINFO_SIZE );
if( pMemBlock->Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XFREEINV, "hb_xfree called with an invalid pointer", NULL, NULL );
if( HB_GET_LE_UINT32( ( ( HB_BYTE * ) pMem ) + pMemBlock->nSize ) != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XMEMOVERFLOW, "Memory buffer overflow", NULL, NULL );
s_nMemoryConsumed -= pMemBlock->nSize;
s_nMemoryBlocks--;
if( s_pMemBlocks == pMemBlock )
s_pMemBlocks = pMemBlock->pNextBlock;
else
pMemBlock->pPrevBlock->pNextBlock = pMemBlock->pNextBlock;
if( pMemBlock->pNextBlock )
pMemBlock->pNextBlock->pPrevBlock = pMemBlock->pPrevBlock;
pMemBlock->Signature = 0;
HB_PUT_LE_UINT32( ( ( HB_BYTE * ) pMem ) + pMemBlock->nSize, 0 );
pMem = ( HB_BYTE * ) pMem - HB_MEMINFO_SIZE;
#endif
free( pMem );
}
else
hb_errInternal( HB_EI_XFREENULL, "hb_xfree called with a NULL pointer", NULL, NULL );
}
static PHB_TASKINFO hb_taskSwitchLock( PHB_TASKMTX pMutex )
{
PHB_TASKINFO pTask = pMutex->lockers;
if( pTask )
{
pMutex->lockers = pTask->pBlockNext;
#ifdef HB_TASK_DEBUG
if( pTask->locking != pMutex )
hb_errInternal( HB_EI_ERRUNRECOV, "TaskSwitchLock: broken lock", NULL, NULL );
#endif
pTask->locking = NULL;
pTask->locked++;
pMutex->task = pTask;
pMutex->count = 1;
if( pTask->state == TASK_SLEEPING )
{
hb_taskWakeUp( pTask );
pTask->state = TASK_RUNNING;
}
else if( pTask->state != TASK_RUNNING )
hb_errInternal( HB_EI_ERRUNRECOV, "TaskSwitchLock: task resumed", NULL, NULL );
}
return pTask;
}
void hb_compPCodeEval( PFUNCTION pFunc, const HB_PCODE_FUNC_PTR * pFunctions, void * cargo )
{
HB_SIZE nPos = 0;
HB_SIZE nSkip;
HB_BYTE opcode;
/* Make sure that table is correct */
assert( sizeof( hb_comp_pcode_len ) == HB_P_LAST_PCODE );
assert( sizeof( s_psize_table ) / sizeof( HB_PCODE_FUNC_PTR ) == HB_P_LAST_PCODE );
while( nPos < pFunc->nPCodePos )
{
opcode = pFunc->pCode[ nPos ];
if( opcode < HB_P_LAST_PCODE )
{
HB_PCODE_FUNC_PTR pCall = pFunctions[ opcode ];
nSkip = pCall ? pCall( pFunc, nPos, cargo ) : 0;
if( nSkip == 0 )
{
nSkip = hb_comp_pcode_len[ opcode ];
if( nSkip == 0 )
{
pCall = s_psize_table[ opcode ];
if( pCall != NULL )
nSkip = pCall( pFunc, nPos, NULL );
}
}
if( nSkip == 0 )
{
char szOpcode[ 16 ];
++nPos;
hb_snprintf( szOpcode, sizeof( szOpcode ), "%i", opcode );
hb_errInternal( HB_EI_COMPBADOPSIZE, "Invalid (zero) opcode %s size in hb_compPCodeEval()", szOpcode, NULL );
}
#if 0
/*
* Test code to validate return values by PCODE eval functions,
* in some cases the eval functions can return intentionally differ
* values so it's not enabled by default. [druzus]
*/
if( hb_comp_pcode_len[ opcode ] != 0 && hb_comp_pcode_len[ opcode ] != nSkip )
{
char szMsg[ 100 ];
hb_snprintf( szMsg, sizeof( szMsg ), "Wrong PCODE (%d) size (%ld!=%d)", opcode, nSkip, hb_comp_pcode_len[ opcode ] );
hb_errInternal( HB_EI_COMPBADOPSIZE, szMsg, NULL, NULL );
}
#endif
nPos += nSkip;
}
else
{
char szOpcode[ 16 ];
++nPos;
hb_snprintf( szOpcode, sizeof( szOpcode ), "%i", opcode );
hb_errInternal( HB_EI_COMPBADOPCODE, "Invalid opcode: %s in hb_compPCodeEval()", szOpcode, NULL );
}
}
}
static void hb_ocidd_init( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
if( ! OCI_Initialize( NULL, NULL, OCI_ENV_DEFAULT | OCI_ENV_CONTEXT | OCI_ENV_THREADED ) )
hb_errInternal( 8000, NULL, NULL, NULL );
else if( ! hb_sddRegister( &s_ocidd ) )
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
}
void * hb_xrealloc( void * pMem, HB_SIZE nSize ) /* reallocates memory */
{
#ifdef HB_FM_STATISTICS
PHB_MEMINFO pMemBlock;
HB_SIZE nMemSize;
void * pResult;
if( nSize == 0 )
{
if( pMem )
hb_xfree( pMem );
return NULL;
}
else if( ! pMem )
return hb_xgrab( nSize );
pMemBlock = ( PHB_MEMINFO ) ( ( HB_BYTE * ) pMem - HB_MEMINFO_SIZE );
nMemSize = pMemBlock->nSize;
if( pMemBlock->Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XREALLOCINV, "hb_xrealloc called with an invalid pointer", NULL, NULL );
if( HB_GET_LE_UINT32( ( ( HB_BYTE * ) pMem ) + nMemSize ) != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XMEMOVERFLOW, "Memory buffer overflow", NULL, NULL );
HB_PUT_LE_UINT32( ( ( HB_BYTE * ) pMem ) + nMemSize, 0 );
pResult = realloc( pMemBlock, nSize + HB_MEMINFO_SIZE + sizeof( HB_U32 ) );
if( pResult )
{
if( s_pMemBlocks == pMemBlock )
s_pMemBlocks = ( PHB_MEMINFO ) pResult;
else
( ( PHB_MEMINFO ) pResult )->pPrevBlock->pNextBlock = ( PHB_MEMINFO ) pResult;
if( ( ( PHB_MEMINFO ) pResult )->pNextBlock )
( ( PHB_MEMINFO ) pResult )->pNextBlock->pPrevBlock = ( PHB_MEMINFO ) pResult;
s_nMemoryConsumed += ( nSize - nMemSize );
if( s_nMemoryMaxConsumed < s_nMemoryConsumed )
s_nMemoryMaxConsumed = s_nMemoryConsumed;
( ( PHB_MEMINFO ) pResult )->nSize = nSize; /* size of the memory block */
HB_PUT_LE_UINT32( ( ( HB_BYTE * ) pResult ) + nSize + HB_MEMINFO_SIZE, HB_MEMINFO_SIGNATURE );
pResult = ( HB_BYTE * ) pResult + HB_MEMINFO_SIZE;
}
#else
void * pResult = realloc( pMem, nSize );
#endif
if( ! pResult && nSize )
hb_errInternal( HB_EI_XREALLOC, "hb_xrealloc can't reallocate memory", NULL, NULL );
return pResult;
}
/* Insert new symbol into dynamic symbol table.
* In MT mode caller should protected it by HB_DYNSYM_LOCK()
*/
static PHB_DYNS hb_dynsymInsert( PHB_SYMB pSymbol, HB_UINT uiPos )
{
PHB_DYNS pDynSym;
HB_TRACE( HB_TR_DEBUG, ( "hb_dynsymInsert(%p,%u)", pSymbol, uiPos ) );
if( ++s_uiDynSymbols == 0 )
{
--s_uiDynSymbols;
hb_errInternal( 6004, "Internal error: size of dynamic symbol table exceed", NULL, NULL );
}
else if( s_uiDynSymbols == 1 )
{
s_pDynItems = ( PDYNHB_ITEM ) hb_xgrab( sizeof( DYNHB_ITEM ) );
}
else
{
s_pDynItems = ( PDYNHB_ITEM ) hb_xrealloc( s_pDynItems, s_uiDynSymbols * sizeof( DYNHB_ITEM ) );
memmove( &s_pDynItems[ uiPos + 1 ], &s_pDynItems[ uiPos ],
sizeof( DYNHB_ITEM ) * ( s_uiDynSymbols - uiPos - 1 ) );
}
pDynSym = ( PHB_DYNS ) hb_xgrab( sizeof( HB_DYNS ) );
memset( pDynSym, 0, sizeof( HB_DYNS ) );
pDynSym->pSymbol = pSymbol;
pDynSym->uiSymNum = s_uiDynSymbols;
pSymbol->pDynSym = s_pDynItems[ uiPos ].pDynSym = pDynSym;
return pDynSym;
}
PHB_LANG hb_langSelect( PHB_LANG lang )
{
PHB_LANG langOld = s_lang;
HB_TRACE( HB_TR_DEBUG, ( "hb_langSelect(%p)", lang ) );
if( lang )
{
s_lang = lang;
}
else
{
/*
// Intentionally not using generic rutines which might require valid language setup.
printf( "Internal error: invalid language selected.\n" );
exit(1);
druzus: in hb_errInternal(...) s_lang is checked before so we only have
to set it to NULL to avoid recursion
*/
s_lang = NULL;
hb_errInternal( HB_EI_ERRUNRECOV, "invalid language selected", NULL, NULL );
}
return langOld;
}
static void hb_sdfRddInit( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
if( hb_rddRegister( "SDF", RDT_TRANSFER ) > 1 )
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
}
/* release a memory block allocated with hb_gcAlloc*() */
void hb_gcFree( void * pBlock )
{
if( pBlock )
{
PHB_GARBAGE pAlloc = HB_GC_PTR( pBlock );
/* Don't release the block that will be deleted during finalization */
if( ! ( pAlloc->used & HB_GC_DELETE ) )
{
HB_GC_LOCK();
if( pAlloc->locked )
hb_gcUnlink( &s_pLockedBlock, pAlloc );
else
{
hb_gcUnlink( &s_pCurrBlock, pAlloc );
HB_GC_AUTO_DEC();
}
HB_GC_UNLOCK();
HB_GARBAGE_FREE( pAlloc );
}
}
else
{
hb_errInternal( HB_EI_XFREENULL, NULL, NULL, NULL );
}
}
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 );
}
static void hb_mlzo_init( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
if( lzo_init() != LZO_E_OK )
hb_errInternal( HB_EI_VMBADSTARTUP /* TOFIX: ? */, NULL, NULL, NULL );
}
static void hb_sqlbaseInit( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
if( hb_rddRegister( "SQLBASE", RDT_FULL ) > 1 )
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
}
static PHB_TASKINFO hb_taskNew( long stack_size )
{
PHB_TASKINFO pTask;
HB_PTRUINT new_size;
if( stack_size < HB_TASK_STACK_MIN )
stack_size = HB_TASK_STACK_MIN;
pTask = ( PHB_TASKINFO ) hb_xgrabz( sizeof( HB_TASKINFO ) );
pTask->stack = ( char * ) hb_xgrab( stack_size );
new_size = ( HB_PTRUINT ) pTask->stack + stack_size;
new_size &= ~ ( HB_PTRUINT ) ( HB_TASK_STACK_ALIGN - 1 );
new_size -= ( HB_PTRUINT ) pTask->stack;
pTask->stack_size = ( long ) new_size;
pTask->id = ++s_iTaskID;
pTask->state = TASK_INIT;
#if defined( HB_HAS_UCONTEXT )
/* create new execution context and initialize its private stack */
if( getcontext( &pTask->context ) == -1 )
hb_errInternal( HB_EI_ERRUNRECOV, "getcontext", NULL, NULL );
pTask->context.uc_link = NULL;
pTask->context.uc_stack.ss_sp = pTask->stack;
pTask->context.uc_stack.ss_size = pTask->stack_size;
makecontext( &pTask->context, hb_taskRun, 0 );
#endif
return pTask;
}
ULONG hb_gcDecRef( void *pBlock )
{
HB_GARBAGE_PTR pAlloc = ( HB_GARBAGE_PTR ) pBlock;
--pAlloc;
if( pAlloc->ulHolders == 0 )
{
hb_errInternal( HB_EI_PREMATURE_RELEASE, "Premature Pointer Release detected: '%p'", (char *) pBlock, NULL );
}
if( HB_ATOMIC_DEC( pAlloc->ulHolders ) == 0 && !pAlloc->locked )
{
//OutputDebugString("Calling GC Cleanup function...");
if( pAlloc->pFunc )
{
( pAlloc->pFunc )( ( void * )( pBlock ) );
}
//OutputDebugString("Attempting to free GC mem...");
hb_gcFree( pBlock );
//OutputDebugString("GC mem freed...");
return 0;
}
else
{
return pAlloc->ulHolders;
}
}
static void hb_pgsqldd_init( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
if( ! hb_sddRegister( &pgsqldd ) )
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
}
static void hb_adsxRddInit( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
if( hb_rddRegister( "ADSX", RDT_FULL ) > 1 ||
hb_rddRegister( "ADSNTXX", RDT_FULL ) > 1 ||
hb_rddRegister( "ADSCDXX", RDT_FULL ) > 1 ||
#if ADS_LIB_VERSION >= 900
hb_rddRegister( "ADSVFPX", RDT_FULL ) > 1 ||
#endif
hb_rddRegister( "ADSADTX", RDT_FULL ) > 1 )
{
/* try different RDD register order */
hb_rddRegister( "ADS", RDT_FULL );
hb_rddRegister( "ADSNTX", RDT_FULL );
hb_rddRegister( "ADSCDX", RDT_FULL );
#if ADS_LIB_VERSION >= 900
hb_rddRegister( "ADSVFP", RDT_FULL );
#endif
hb_rddRegister( "ADSADT", RDT_FULL );
if( hb_rddRegister( "ADSX", RDT_FULL ) > 1 ||
hb_rddRegister( "ADSNTXX", RDT_FULL ) > 1 ||
hb_rddRegister( "ADSCDXX", RDT_FULL ) > 1 ||
#if ADS_LIB_VERSION >= 900
hb_rddRegister( "ADSVFPX", RDT_FULL ) > 1 ||
#endif
hb_rddRegister( "ADSADTX", RDT_FULL ) > 1 )
{
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
/* not executed, only to force linking ADS RDD */
HB_FUNC_EXEC( ADSCDX );
}
}
}
HB_ERRCODE hb_memvarGet( PHB_ITEM pItem, PHB_SYMB pMemvarSymb )
{
PHB_DYNS pDyn;
HB_ERRCODE bSuccess = HB_FAILURE;
HB_TRACE( HB_TR_DEBUG, ( "hb_memvarGet(%p, %p)", pItem, pMemvarSymb ) );
pDyn = pMemvarSymb->pDynSym;
if( pDyn )
{
PHB_ITEM pMemvar;
pMemvar = hb_dynsymGetMemvar( pDyn );
HB_TRACE( HB_TR_INFO, ( "Memvar item (%p)(%s) queried", pMemvar, pMemvarSymb->szName ) );
if( pMemvar )
{
/* value is already created
*/
if( HB_IS_BYREF( pMemvar ) )
hb_itemCopy( pItem, hb_itemUnRef( pMemvar ) );
else
hb_itemCopy( pItem, pMemvar );
bSuccess = HB_SUCCESS;
}
}
else
hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL );
return bSuccess;
}
static HB_BOOL hb_errGetNumCode( int * piValue, const char * szOperation )
{
PHB_ITEM pItem = hb_param( 1, HB_IT_NUMERIC );
if( pItem )
*piValue = hb_itemGetNI( pItem );
else
{
pItem = hb_errRT_BASE_Subst( EG_ARG, 0, NULL, szOperation,
HB_ERR_ARGS_BASEPARAMS );
if( ! pItem )
{
*piValue = 0;
return HB_FALSE;
}
if( ! HB_IS_NUMERIC( pItem ) )
hb_errInternal( HB_EI_ERRRECFAILURE, NULL, NULL, NULL );
*piValue = hb_itemGetNI( pItem );
hb_itemRelease( pItem );
}
return HB_TRUE;
}
void hb_compPCodeTrace( PFUNCTION pFunc, const HB_PCODE_FUNC_PTR * pFunctions, void * cargo )
{
HB_SIZE nPos = 0;
/* Make sure that table is correct */
assert( sizeof( hb_comp_pcode_len ) == HB_P_LAST_PCODE );
while( nPos < pFunc->nPCodePos )
{
HB_BYTE opcode = pFunc->pCode[ nPos ];
if( opcode < HB_P_LAST_PCODE )
{
HB_PCODE_FUNC_PTR pCall = pFunctions[ opcode ];
if( pCall )
nPos = pCall( pFunc, nPos, cargo );
else
nPos += hb_comp_pcode_len[ opcode ];
}
else
{
char szOpcode[ 16 ];
++nPos;
hb_snprintf( szOpcode, sizeof( szOpcode ), "%i", opcode );
hb_errInternal( HB_EI_COMPBADOPCODE, "Invalid opcode: %s in hb_compPCodeTrace()", szOpcode, NULL );
}
}
}
/*
* This functions copies passed item value into the memvar pointed
* by symbol
*
* pMemvar - symbol associated with a variable
* pItem - value to store in memvar
*
*/
void hb_memvarSetValue( PHB_SYMB pMemvarSymb, PHB_ITEM pItem )
{
PHB_DYNS pDyn;
HB_TRACE( HB_TR_DEBUG, ( "hb_memvarSetValue(%p, %p)", pMemvarSymb, pItem ) );
pDyn = pMemvarSymb->pDynSym;
if( pDyn )
{
PHB_ITEM pMemvar;
pMemvar = hb_dynsymGetMemvar( pDyn );
HB_TRACE( HB_TR_INFO, ( "Memvar item (%p)(%s) assigned", pMemvar, pMemvarSymb->szName ) );
if( pMemvar )
{
/* value is already created */
hb_itemCopyToRef( pMemvar, pItem );
/* Remove MEMOFLAG if exists (assignment from field). */
pMemvar->type &= ~HB_IT_MEMOFLAG;
}
else
{
/* assignment to undeclared memvar - PRIVATE is assumed */
hb_memvarCreateFromDynSymbol( pDyn, HB_VSCOMP_PRIVATE, pItem );
}
}
else
hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL );
}
void hb_taskSignal( void ** pCondPtr )
{
PHB_TASKCOND pCond;
if( *pCondPtr == NULL )
*pCondPtr = ( void * ) hb_taskCondNew();
pCond = ( PHB_TASKCOND ) *pCondPtr;
if( pCond->waiters )
{
PHB_TASKINFO * pLockers = &pCond->mutex->lockers, pTask;
while( *pLockers )
pLockers = &( *pLockers )->pBlockNext;
pTask = pCond->waiters;
#ifdef HB_TASK_DEBUG
if( pTask->waiting != pCond )
hb_errInternal( HB_EI_ERRUNRECOV, "TaskSignal: broken cond", NULL, NULL );
#endif
pTask->waiting = NULL;
pCond->waiters = pTask->pWaitNext;
pTask->locking = pCond->mutex;
pTask->pBlockNext = NULL;
*pLockers = pTask;
if( pCond->mutex->count == 0 )
hb_taskSwitchLock( pCond->mutex );
}
}
/* TODO: do not start task immediately */
void hb_taskResume( void * pTaskPtr )
{
PHB_TASKINFO pTask = ( PHB_TASKINFO ) pTaskPtr, pCurrTask;
if( s_currTask != pTask )
{
pCurrTask = s_currTask;
switch( pTask->state )
{
#if ! defined( HB_HAS_UCONTEXT )
case TASK_INIT:
/* save current execution context */
if( setjmp( s_currTask->context ) == 0 )
{
s_currTask = pTask;
hb_taskStart();
/* unreachable code */
}
break;
#endif
case TASK_SLEEPING:
hb_taskWakeUp( pTask );
/* no break */
#if defined( HB_HAS_UCONTEXT )
case TASK_INIT:
#endif
case TASK_SUSPEND:
pTask->state = TASK_RUNNING;
/* no break */
case TASK_RUNNING:
#if defined( HB_HAS_UCONTEXT )
s_currTask = pTask;
/* save current execution context and switch to the new one */
swapcontext( &pCurrTask->context, &pTask->context );
#else
/* save current execution context */
if( setjmp( s_currTask->context ) == 0 )
{
s_currTask = pTask;
/* switch execution context */
longjmp( pTask->context, 1 );
/* unreachable code */
}
#endif
break;
case TASK_DONE:
break;
case TASK_ZOMBIE:
/* It should not happen - it's bug in user code */
hb_errInternal( HB_EI_ERRUNRECOV, "TaskResume: zombie", NULL, NULL );
/*
default:
hb_errInternal( HB_EI_ERRUNRECOV, "TaskResume: corrupt", NULL, NULL );
*/
}
}
}
PHB_ITEM hb_errNew( void )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_errNew()" ) );
if( ! s_pError || ! HB_IS_OBJECT( s_pError ) )
hb_errInternal( HB_EI_ERRRECFAILURE, NULL, NULL, NULL );
return hb_arrayClone( s_pError );
}
/* (try to) lock given mutex */
int hb_taskLock( void ** pMutexPtr, unsigned long ulMilliSec )
{
PHB_TASKMTX pMutex;
if( s_iTaskID == 0 )
return 0;
if( *pMutexPtr == NULL )
*pMutexPtr = ( void * ) hb_taskMutexNew();
pMutex = ( PHB_TASKMTX ) *pMutexPtr;
if( pMutex->count == 0 )
{
s_currTask->locked++;
pMutex->task = s_currTask;
return ++pMutex->count;
}
else if( pMutex->task == s_currTask )
{
return ++pMutex->count;
}
if( ulMilliSec )
{
PHB_TASKINFO * pLockers = &pMutex->lockers;
while( *pLockers )
pLockers = &( *pLockers )->pBlockNext;
*pLockers = s_currTask;
s_currTask->pBlockNext = NULL;
s_currTask->locking = pMutex;
hb_taskSleep( ulMilliSec );
if( s_currTask->locking )
{
pLockers = &pMutex->lockers;
while( *pLockers )
{
if( *pLockers == s_currTask )
{
*pLockers = s_currTask->pBlockNext;
s_currTask->locking = NULL;
break;
}
else
pLockers = &( *pLockers )->pBlockNext;
}
#ifdef HB_TASK_DEBUG
if( s_currTask->locking )
hb_errInternal( HB_EI_ERRUNRECOV, "TaskLock: dummy lock", NULL, NULL );
#endif
}
}
return pMutex->task == s_currTask ? pMutex->count : 0;
}
static void hb_mysqldd_init( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
if( ! hb_sddRegister( &s_mysqldd ) ||
( sizeof( MYSQL_ROW_OFFSET ) != sizeof( void * ) ) )
{
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
}
}
static void hb_sqlt3dd_init( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
#if SQLITE_VERSION_NUMBER >= 3006000
sqlite3_initialize();
#endif
if( ! hb_sddRegister( &s_sqlt3dd ) )
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
}
void hb_conInit( void )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_conInit()" ) );
#if ! defined( HB_OS_WIN )
/* On Windows file handles with numbers 0, 1, 2 are
transalted inside filesys to:
GetStdHandle( STD_INPUT_HANDLE ), GetStdHandle( STD_OUTPUT_HANDLE ),
GetStdHandle( STD_ERROR_HANDLE ) */
s_hFilenoStdin = fileno( stdin );
s_hFilenoStdout = fileno( stdout );
s_hFilenoStderr = fileno( stderr );
#endif
#ifdef HB_CLP_UNDOC
{
/* Undocumented CA-Cl*pper switch //STDERR:x */
int iStderr = hb_cmdargNum( "STDERR" );
if( iStderr == 0 || iStderr == 1 ) /* //STDERR with no parameter or 0 */
s_hFilenoStderr = s_hFilenoStdout;
/* disabled in default builds. It's not multiplatform and very
* dangerous because it can redirect error messages to data files
* [druzus]
*/
#ifdef HB_CLP_STRICT
else if( iStderr > 0 ) /* //STDERR:x */
s_hFilenoStderr = ( HB_FHANDLE ) iStderr;
#endif
}
#endif
/*
* Some compilers open stdout and stderr in text mode, but
* Harbour needs them to be open in binary mode.
*/
hb_fsSetDevMode( s_hFilenoStdin, FD_BINARY );
hb_fsSetDevMode( s_hFilenoStdout, FD_BINARY );
hb_fsSetDevMode( s_hFilenoStderr, FD_BINARY );
if( hb_gtInit( s_hFilenoStdin, s_hFilenoStdout, s_hFilenoStderr ) != HB_SUCCESS )
hb_errInternal( 9995, "Harbour terminal (GT) initialization failure", NULL, NULL );
if( hb_cmdargCheck( "INFO" ) )
{
hb_conOutErr( hb_gtVersion( 1 ), 0 );
hb_conOutErr( hb_conNewLine(), 0 );
}
}
void hb_taskDestroyCond( void ** pCondPtr )
{
PHB_TASKCOND pCond = ( PHB_TASKCOND ) *pCondPtr;
if( pCond )
{
PHB_TASKCOND * pCondLst = &s_condList;
while( *pCondLst )
{
if( *pCondLst == pCond )
{
*pCondLst = pCond->next;
if( pCond->waiters )
hb_errInternal( HB_EI_ERRUNRECOV, "TaskDestroyCond: waiters", NULL, NULL );
hb_xfree( pCond );
return;
}
pCondLst = &( *pCondLst )->next;
}
hb_errInternal( HB_EI_ERRUNRECOV, "TaskDestroyCond: not a cond", NULL, NULL );
}
}
void * hb_xgrab( HB_SIZE nSize ) /* allocates fixed memory, exits on failure */
{
void * pMem;
if( nSize == 0 )
hb_errInternal( HB_EI_XGRABNULLSIZE, "hb_xgrab requested to allocate zero bytes", NULL, NULL );
#ifdef HB_FM_STATISTICS
pMem = malloc( nSize + HB_MEMINFO_SIZE + sizeof( HB_U32 ) );
if( pMem )
{
if( s_pMemBlocks )
s_pMemBlocks->pPrevBlock = ( PHB_MEMINFO ) pMem;
( ( PHB_MEMINFO ) pMem )->pNextBlock = s_pMemBlocks;
( ( PHB_MEMINFO ) pMem )->pPrevBlock = NULL;
s_pMemBlocks = ( PHB_MEMINFO ) pMem;
( ( PHB_MEMINFO ) pMem )->nSize = nSize;
( ( PHB_MEMINFO ) pMem )->Signature = HB_MEMINFO_SIGNATURE;
HB_PUT_LE_UINT32( ( ( HB_BYTE * ) pMem ) + HB_MEMINFO_SIZE + nSize, HB_MEMINFO_SIGNATURE );
s_nMemoryConsumed += nSize;
if( s_nMemoryMaxConsumed < s_nMemoryConsumed )
s_nMemoryMaxConsumed = s_nMemoryConsumed;
s_nMemoryBlocks++;
if( s_nMemoryMaxBlocks < s_nMemoryBlocks )
s_nMemoryMaxBlocks = s_nMemoryBlocks;
pMem = ( HB_BYTE * ) pMem + HB_MEMINFO_SIZE;
}
else
#else
pMem = malloc( nSize );
if( ! pMem )
#endif
hb_errInternal( HB_EI_XGRABALLOC, "hb_xgrab can't allocate memory", NULL, NULL );
return pMem;
}
