int main( int argc, char * argv[] ) { HB_TRACE(HB_TR_DEBUG, ("main(%d, %p)", argc, argv)); #if defined(HB_OS_WIN_32) hb_gtSetDefault( "win" ); #endif hb_cmdargInit( argc, argv ); hb_vmInit( TRUE ); return hb_vmQuit(); }
HB_EXTERN_END int main( int argc, char * argv[] ) { HB_TRACE( HB_TR_DEBUG, ( "main(%d, %p)", argc, ( void * ) argv ) ); #if defined( __DJGPP__ ) __system_flags = __system_redirect | __system_allow_long_cmds | __system_emulate_command | __system_handle_null_commands | __system_emulate_chdir; #endif hb_cmdargInit( argc, argv ); hb_vmInit( HB_TRUE ); return hb_vmQuit(); }
BOOL WINAPI DllMain( HINSTANCE hInstance, DWORD dwReason, PVOID pvReserved ) #endif { static HB_BOOL s_fInit = HB_FALSE; BOOL fResult = TRUE; HB_SYMBOL_UNUSED( pvReserved ); switch( dwReason ) { case DLL_PROCESS_ATTACH: s_hInstDll = ( HINSTANCE ) hInstance; s_lLockCount = s_lObjectCount = 0; s_IClassFactoryObj.lpVtbl = ( IClassFactoryVtbl * ) &IClassFactory_Vtbl; DisableThreadLibraryCalls( ( HMODULE ) hInstance ); s_fInit = ! hb_vmIsActive(); if( s_fInit ) hb_vmInit( HB_FALSE ); hb_oleInit(); if( ! s_fServerReady ) { PHB_DYNS pDynSym = hb_dynsymFind( "DLLMAIN" ); if( pDynSym && hb_dynsymIsFunction( pDynSym ) && hb_vmRequestReenter() ) { hb_vmPushDynSym( pDynSym ); hb_vmPushNil(); hb_vmProc( 0 ); hb_vmRequestRestore(); } } fResult = s_fServerReady ? TRUE : FALSE; break; case DLL_PROCESS_DETACH: s_fServerReady = HB_FALSE; if( s_pAction ) { hb_itemRelease( s_pAction ); s_pAction = NULL; } if( s_pMsgHash ) { hb_itemRelease( s_pMsgHash ); s_pMsgHash = NULL; } if( s_fInit ) { hb_vmQuit(); s_fInit = HB_FALSE; } break; } return fResult; }
//------------------------------- // 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 ); } }*/ }
int main( int argc, char * argv[] ) { hb_cmdargInit( argc, argv ); hb_vmInit( HB_TRUE ); return hb_vmQuit(); }
int APIENTRY WinMain( HINSTANCE hInstance, /* handle to current instance */ HINSTANCE hPrevInstance, /* handle to previous instance */ LPSTR lpCmdLine, /* pointer to command line */ int iCmdShow ) /* show state of window */ { #ifdef HB_FM_WIN32_ALLOC LPSTR pArgs = ( LPSTR ) LocalAlloc( LMEM_FIXED, strlen( lpCmdLine ) + 1 ); #else LPSTR pArgs = ( LPSTR ) malloc( strlen( lpCmdLine ) + 1 ); #endif LPSTR pStart, pArg = pArgs; BOOL bInQuotedParam; int iResult; HB_TRACE( HB_TR_DEBUG, ( "WinMain(%p, %p, %s, %d)", hInstance, hPrevInstance, lpCmdLine, iCmdShow ) ); HB_SYMBOL_UNUSED( iCmdShow ); hb_gtSetDefault( "gui" ); GetModuleFileName( hInstance, s_szAppName, sizeof( s_szAppName ) - 1 ); s_argv[ s_argc++ ] = s_szAppName; while( *lpCmdLine && s_argc < MAX_ARGS ) { while( *lpCmdLine == ' ' ) /* Skip over any white space */ lpCmdLine++; if( *lpCmdLine ) { pStart = NULL; bInQuotedParam = FALSE; while( *lpCmdLine ) { if( *lpCmdLine == '"' ) { lpCmdLine++; if( bInQuotedParam ) { if( pStart == NULL ) pStart = pArg; break; } else bInQuotedParam = TRUE; } else if( *lpCmdLine == ' ' ) { if( bInQuotedParam ) { *pArg = *lpCmdLine++; if( pStart == NULL ) pStart = pArg; pArg++; } else { lpCmdLine++; break; } } else { *pArg = *lpCmdLine++; if( pStart == NULL ) pStart = pArg; pArg++; } } if( pStart ) { *pArg++ = '\0'; s_argv[ s_argc++ ] = pStart; } } } hb_winmainArgInit( hInstance, hPrevInstance, iCmdShow ); hb_cmdargInit( s_argc, s_argv ); hb_vmInit( TRUE ); iResult = hb_vmQuit(); #ifdef HB_FM_WIN32_ALLOC LocalFree( pArgs ); #else free( pArgs ); #endif return iResult; }
/* 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; }
void Java_su_harbour_hDroidGUI_Harbour_vmQuit( JNIEnv* env, jobject thiz ) { hb_vmQuit(); }