PHB_ITEM hb_errPutTries( PHB_ITEM pError, HB_USHORT uiTries )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_errPutTries(%p, %hu)", pError, uiTries ) );
hb_arraySetNI( pError, HB_TERROR_TRIES, uiTries );
return pError;
}
PHB_ITEM hb_errPutSubCode( PHB_ITEM pError, HB_ERRCODE errSubCode )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_errPutSubCode(%p, %d)", pError, errSubCode ) );
hb_arraySetNI( pError, HB_TERROR_SUBCODE, errSubCode );
return pError;
}
PHB_ITEM hb_errPutSeverity( PHB_ITEM pError, HB_USHORT uiSeverity )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_errPutSeverity(%p, %hu)", pError, uiSeverity ) );
hb_arraySetNI( pError, HB_TERROR_SEVERITY, uiSeverity );
return pError;
}
PHB_ITEM hb_errPutFlags( PHB_ITEM pError, HB_USHORT uiFlags )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_errPutFlags(%p, %hu)", pError, uiFlags ) );
uiFlags &= EF_CANRETRY | EF_CANSUBSTITUTE | EF_CANDEFAULT;
hb_arraySetNI( pError, HB_TERROR_FLAGS, uiFlags );
return pError;
}
//-------------------------------
// Manager of signals for windows
//
static LONG s_signalHandler( int type, int sig, PEXCEPTION_RECORD exc )
{
PHB_ITEM pFunction, pExecArray, pRet;
ULONG ulPos;
UINT uiSig, uiMask;
int iRet;
// let's find the right signal handler.
HB_CRITICAL_LOCK( s_ServiceMutex );
// avoid working if PRG signal handling has been disabled
if ( ! bSignalEnabled )
{
HB_CRITICAL_UNLOCK( s_ServiceMutex );
return EXCEPTION_EXECUTE_HANDLER;
}
bSignalEnabled = FALSE;
ulPos = hb_arrayLen( sp_hooks );
// subsig not necessary
uiSig = (UINT) s_translateSignal( (UINT)type, (UINT)sig );
while( ulPos > 0 )
{
pFunction = hb_arrayGetItemPtr( sp_hooks, ulPos );
uiMask = (UINT) hb_arrayGetNI( pFunction, 1 );
if ( (uiMask & uiSig) == uiSig )
{
// we don't unlock the mutex now, even if it is
// a little dangerous. But we are in a signal hander...
// for now just 2 parameters
pExecArray = hb_itemArrayNew( 3 );
hb_arraySetForward( pExecArray, 1, hb_arrayGetItemPtr( pFunction, 2 ) );
hb_arraySetNI( pExecArray, 2, uiSig );
/* the third parameter is an array:
* 1: low-level signal
* 2: low-level subsignal
* 3: low-level system error
* 4: address that rised the signal
* 5: process id of the signal riser
* 6: UID of the riser
*/
pRet = hb_arrayGetItemPtr( pExecArray, 3);
hb_arrayNew( pRet, 6 );
hb_arraySetNI( pRet, HB_SERVICE_OSSIGNAL, type );
hb_arraySetNI( pRet, HB_SERVICE_OSSUBSIG, sig );
//could be meaningless, but does not matter here
hb_arraySetNI( pRet, HB_SERVICE_OSERROR, GetLastError() );
if (type == 0 ) //exception
{
hb_arraySetPtr( pRet, HB_SERVICE_ADDRESS, ( void * ) exc->ExceptionAddress );
}
else
{
hb_arraySetPtr( pRet, HB_SERVICE_ADDRESS, NULL );
}
//TODO:
hb_arraySetNI( pRet, HB_SERVICE_PROCESS, GetCurrentThreadId() );
//TODO:
hb_arraySetNI( pRet, HB_SERVICE_UID, 0 );
pRet = hb_itemDo( pExecArray, 0 );
iRet = hb_itemGetNI( pRet );
hb_itemRelease( pRet );
hb_itemRelease( pExecArray );
switch( iRet )
{
case HB_SERVICE_HANDLED:
bSignalEnabled = TRUE;
HB_CRITICAL_UNLOCK( s_ServiceMutex );
return EXCEPTION_CONTINUE_EXECUTION;
case HB_SERVICE_QUIT:
bSignalEnabled = FALSE;
HB_CRITICAL_UNLOCK( s_ServiceMutex );
hb_vmRequestQuit();
#ifndef HB_THREAD_SUPPORT
hb_vmQuit();
exit(0);
#else
hb_threadCancelInternal();
#endif
}
}
ulPos--;
}
bSignalEnabled = TRUE;
return EXCEPTION_EXECUTE_HANDLER;
}
static void s_signalHandler( int sig, siginfo_t *info, void *v )
#endif
{
UINT uiMask;
UINT uiSig;
PHB_ITEM pFunction, pExecArray, pRet;
ULONG ulPos;
int iRet;
#if !( defined( HB_OS_OS2_GCC ) || defined( __WATCOMC__ ) )
HB_SYMBOL_UNUSED(v);
#endif
// let's find the right signal handler.
HB_CRITICAL_LOCK( s_ServiceMutex );
// avoid working if PRG signal handling has been disabled
if ( ! bSignalEnabled )
{
HB_CRITICAL_UNLOCK( s_ServiceMutex );
return;
}
bSignalEnabled = FALSE;
ulPos = hb_arrayLen( sp_hooks );
// subsig not necessary
uiSig = (UINT) s_translateSignal( (UINT)sig, 0 );
while( ulPos > 0 )
{
pFunction = hb_arrayGetItemPtr( sp_hooks, ulPos );
uiMask = (UINT) hb_arrayGetNI( pFunction, 1 );
if ( uiMask & uiSig)
{
// we don't unlock the mutex now, even if it is
// a little dangerous. But we are in a signal hander...
// for now just 2 parameters
pExecArray = hb_itemArrayNew( 3 );
hb_arraySet( pExecArray, 1, hb_arrayGetItemPtr( pFunction, 2 ) );
hb_arraySetNI( pExecArray, 2, uiSig );
// the third parameter is an array:
pRet = hb_arrayGetItemPtr( pExecArray, 3);
#if defined( HB_OS_OS2_GCC ) || defined( __WATCOMC__ )
hb_arrayNew( pRet, 1 );
#elif defined( HB_OS_BSD )
hb_arrayNew( pRet, info ? 6 : 1 );
#else
hb_arrayNew( pRet, 6 );
#endif
hb_arraySetNI( pRet, HB_SERVICE_OSSIGNAL, sig );
#if !( defined( HB_OS_OS2_GCC ) || defined( __WATCOMC__ ) )
#if defined( HB_OS_BSD )
if (info)
#endif
{
hb_arraySetNI( pRet, HB_SERVICE_OSSUBSIG, info->si_code );
hb_arraySetNI( pRet, HB_SERVICE_OSERROR, info->si_errno );
hb_arraySetPtr( pRet, HB_SERVICE_ADDRESS, (void *) info->si_addr );
hb_arraySetNI( pRet, HB_SERVICE_PROCESS, info->si_pid );
hb_arraySetNI( pRet, HB_SERVICE_UID, info->si_uid );
}
#endif
pRet = hb_itemDo( pExecArray, 0 );
iRet = hb_itemGetNI( pRet );
hb_itemRelease( pRet );
hb_itemRelease( pExecArray );
switch( iRet )
{
case HB_SERVICE_HANDLED:
bSignalEnabled = TRUE;
HB_CRITICAL_UNLOCK( s_ServiceMutex );
return;
case HB_SERVICE_QUIT:
bSignalEnabled = FALSE;
HB_CRITICAL_UNLOCK( s_ServiceMutex );
//TODO: A service cleanup routine
hb_vmRequestQuit();
#ifndef HB_THREAD_SUPPORT
hb_vmQuit();
exit(0);
#else
/* Allow signals to go through pthreads */
s_serviceSetDflSig();
/* NOTICE: should be pthread_exit(0), but a bug in linuxthread prevents it:
calling pthread exit from a signal handler will cause infinite wait for
restart signal.
This solution is rude, while the other would allow clean VM termination...
but it works.
*/
exit(0);
#endif
}
}
ulPos--;
}
bSignalEnabled = TRUE;
/*s_serviceSetHBSig();*/
/* TODO
if ( uiSig != HB_SIGNAL_UNKNOWN )
{
if ( sa_oldAction[ sig ].sa_flags & SA_SIGINFO )
{
sa_oldAction[ sig ].sa_sigaction( sig, info, v );
}
else
{
sa_oldAction[ sig ].sa_handler( sig );
}
}*/
}
/* Manager of signals for windows */
static LONG s_signalHandler( int type, int sig, PEXCEPTION_RECORD exc )
{
HB_SIZE nPos;
HB_UINT uiSig;
/* let's find the right signal handler. */
hb_threadEnterCriticalSectionGC( &s_ServiceMutex );
/* avoid working if PRG signal handling has been disabled */
if( ! s_bSignalEnabled )
{
hb_threadLeaveCriticalSection( &s_ServiceMutex );
return EXCEPTION_EXECUTE_HANDLER;
}
s_bSignalEnabled = HB_FALSE;
nPos = hb_arrayLen( s_pHooks );
/* subsig not necessary */
uiSig = ( HB_UINT ) s_translateSignal( ( HB_UINT ) type, ( HB_UINT ) sig );
while( nPos > 0 )
{
PHB_ITEM pFunction;
HB_UINT uiMask;
pFunction = hb_arrayGetItemPtr( s_pHooks, nPos );
uiMask = ( HB_UINT ) hb_arrayGetNI( pFunction, 1 );
if( ( uiMask & uiSig ) == uiSig )
{
PHB_ITEM pExecArray, pRet;
int iRet;
/* we don't unlock the mutex now, even if it is
a little dangerous. But we are in a signal hander...
for now just 2 parameters */
pExecArray = hb_itemArrayNew( 3 );
hb_arraySetForward( pExecArray, 1, hb_arrayGetItemPtr( pFunction, 2 ) );
hb_arraySetNI( pExecArray, 2, uiSig );
/* the third parameter is an array:
* 1: low-level signal
* 2: low-level subsignal
* 3: low-level system error
* 4: address that rose the signal
* 5: process id of the signal riser
* 6: UID of the riser
*/
pRet = hb_arrayGetItemPtr( pExecArray, 3 );
hb_arrayNew( pRet, 6 );
hb_arraySetNI( pRet, HB_SERVICE_OSSIGNAL, type );
hb_arraySetNI( pRet, HB_SERVICE_OSSUBSIG, sig );
/* could be meaningless, but does not matter here */
hb_arraySetNI( pRet, HB_SERVICE_OSERROR, GetLastError() );
if( type == 0 ) /* exception */
hb_arraySetPtr( pRet, HB_SERVICE_ADDRESS, ( void * ) exc->ExceptionAddress );
else
hb_arraySetPtr( pRet, HB_SERVICE_ADDRESS, NULL );
/* TODO: */
hb_arraySetNI( pRet, HB_SERVICE_PROCESS, GetCurrentThreadId() );
/* TODO: */
hb_arraySetNI( pRet, HB_SERVICE_UID, 0 );
pRet = hb_itemDo( pExecArray, 0 );
iRet = hb_itemGetNI( pRet );
hb_itemRelease( pRet );
hb_itemRelease( pExecArray );
switch( iRet )
{
case HB_SERVICE_HANDLED:
s_bSignalEnabled = HB_TRUE;
hb_threadLeaveCriticalSection( &s_ServiceMutex );
return EXCEPTION_CONTINUE_EXECUTION;
case HB_SERVICE_QUIT:
s_bSignalEnabled = HB_FALSE;
hb_threadLeaveCriticalSection( &s_ServiceMutex );
hb_vmRequestQuit();
#ifndef HB_THREAD_SUPPORT
hb_vmQuit();
exit( 0 );
#else
hb_threadCancelInternal();
#endif
}
}
nPos--;
}
s_bSignalEnabled = HB_TRUE;
return EXCEPTION_EXECUTE_HANDLER;
}
static void s_signalHandler( int sig, siginfo_t * info, void * v )
#endif
{
HB_UINT uiSig;
HB_SIZE nPos;
#if ! ( defined( HB_OS_OS2_GCC ) || defined( __WATCOMC__ ) )
HB_SYMBOL_UNUSED( v );
#endif
/* let's find the right signal handler. */
hb_threadEnterCriticalSectionGC( &s_ServiceMutex );
/* avoid working if PRG signal handling has been disabled */
if( ! s_bSignalEnabled )
{
hb_threadLeaveCriticalSection( &s_ServiceMutex );
return;
}
s_bSignalEnabled = HB_FALSE;
nPos = hb_arrayLen( s_pHooks );
/* subsig not necessary */
uiSig = ( HB_UINT ) s_translateSignal( ( HB_UINT ) sig, 0 );
while( nPos > 0 )
{
PHB_ITEM pFunction;
HB_UINT uiMask;
pFunction = hb_arrayGetItemPtr( s_pHooks, nPos );
uiMask = ( HB_UINT ) hb_arrayGetNI( pFunction, 1 );
if( uiMask & uiSig )
{
PHB_ITEM pExecArray, pRet;
int iRet;
/* we don't unlock the mutex now, even if it is
a little dangerous. But we are in a signal hander...
for now just 2 parameters */
pExecArray = hb_itemArrayNew( 3 );
hb_arraySet( pExecArray, 1, hb_arrayGetItemPtr( pFunction, 2 ) );
hb_arraySetNI( pExecArray, 2, uiSig );
/* the third parameter is an array: */
pRet = hb_arrayGetItemPtr( pExecArray, 3 );
#if defined( HB_OS_OS2_GCC ) || defined( __WATCOMC__ )
hb_arrayNew( pRet, 1 );
#elif defined( HB_OS_BSD )
hb_arrayNew( pRet, info ? 6 : 1 );
#else
hb_arrayNew( pRet, 6 );
#endif
hb_arraySetNI( pRet, HB_SERVICE_OSSIGNAL, sig );
#if ! ( defined( HB_OS_OS2_GCC ) || defined( __WATCOMC__ ) )
#if defined( HB_OS_BSD )
if( info )
#endif
{
hb_arraySetNI( pRet, HB_SERVICE_OSSUBSIG, info->si_code );
#if ! defined( HB_OS_VXWORKS )
hb_arraySetNI( pRet, HB_SERVICE_OSERROR, info->si_errno );
hb_arraySetPtr( pRet, HB_SERVICE_ADDRESS, ( void * ) info->si_addr );
hb_arraySetNI( pRet, HB_SERVICE_PROCESS, info->si_pid );
hb_arraySetNI( pRet, HB_SERVICE_UID, info->si_uid );
#endif
}
#endif
pRet = hb_itemDo( pExecArray, 0 );
iRet = hb_itemGetNI( pRet );
hb_itemRelease( pRet );
hb_itemRelease( pExecArray );
switch( iRet )
{
case HB_SERVICE_HANDLED:
s_bSignalEnabled = HB_TRUE;
hb_threadLeaveCriticalSection( &s_ServiceMutex );
return;
case HB_SERVICE_QUIT:
s_bSignalEnabled = HB_FALSE;
hb_threadLeaveCriticalSection( &s_ServiceMutex );
/* TODO: A service cleanup routine */
hb_vmRequestQuit();
/* Allow signals to go through pthreads */
s_serviceSetDflSig();
/* NOTICE: should be pthread_exit(0), but a bug in Linux threading prevents it:
calling pthread exit from a signal handler will cause infinite wait for
restart signal.
This solution is rude, while the other would allow clean VM termination...
but it works.
*/
exit( 0 );
}
}
nPos--;
}
s_bSignalEnabled = HB_TRUE;
#if 0
s_serviceSetHBSig();
#endif
#if 0
if( uiSig != HB_SIGNAL_UNKNOWN )
{
if( s_aOldAction[ sig ].sa_flags & SA_SIGINFO )
s_aOldAction[ sig ].sa_sigaction( sig, info, v );
else
s_aOldAction[ sig ].sa_handler( sig );
}
#endif
}
PHB_ITEM wvg_logfontTOarray( LPLOGFONT lf, HB_BOOL bEmpty )
{
PHB_ITEM aFont = hb_itemNew( NULL );
hb_arrayNew( aFont, 15 );
if( bEmpty )
{
hb_arraySetC( aFont, 1, NULL );
hb_arraySetNL( aFont, 2, 0 );
hb_arraySetNL( aFont, 3, 0 );
hb_arraySetNL( aFont, 4, 0 );
hb_arraySetL( aFont, 5, 0 );
hb_arraySetL( aFont, 6, 0 );
hb_arraySetL( aFont, 7, 0 );
hb_arraySetNI( aFont, 8, 0 );
hb_arraySetNI( aFont, 9, 0 );
hb_arraySetNI( aFont, 10, 0 );
hb_arraySetNI( aFont, 11, 0 );
hb_arraySetNI( aFont, 12, 0 );
hb_arraySetNI( aFont, 13, 0 );
hb_arraySetNI( aFont, 14, 0 );
hb_arraySetNInt( aFont, 15, 0 );
}
else
{
HB_ARRAYSETSTR( aFont, 1, lf->lfFaceName );
hb_arraySetNL( aFont, 2, lf->lfHeight );
hb_arraySetNL( aFont, 3, lf->lfWidth );
hb_arraySetNL( aFont, 4, lf->lfWeight );
hb_arraySetL( aFont, 5, lf->lfItalic );
hb_arraySetL( aFont, 6, lf->lfUnderline );
hb_arraySetL( aFont, 7, lf->lfStrikeOut );
hb_arraySetNI( aFont, 8, lf->lfCharSet );
hb_arraySetNI( aFont, 9, lf->lfEscapement );
hb_arraySetNI( aFont, 10, lf->lfOrientation );
hb_arraySetNI( aFont, 11, lf->lfOutPrecision );
hb_arraySetNI( aFont, 12, lf->lfClipPrecision );
hb_arraySetNI( aFont, 13, lf->lfQuality );
hb_arraySetNI( aFont, 14, lf->lfPitchAndFamily );
}
return aFont;
}
