void CheckStop( void ) /***************************/ { if( LinkState & STOP_WORKING ) { Suicide(); } }
pointer CGAlloc( size_t size ) /****************************/ { pointer chunk; _MemLow; for( ;; ) { #if _MEMORY_TRACKING & _FULL_TRACKING chunk = _trmem_alloc( size, _trmem_guess_who(), Handle ); #else chunk = _SysAlloc( size ); #endif if( chunk != NULL ) { #if _MEMORY_TRACKING & _CHUNK_TRACKING ++Chunks; #endif _AlignmentCheck( chunk, 8 ); return( chunk ); } if( !_MemCheck( size ) ) { break; } } if( ( MemOut == MO_FATAL ) || ( InOptimizer != 0 ) ) { FatalError( "Out of memory" ); } else if( MemOut == MO_SUICIDE ) { Suicide(); } return( NULL ); }
void IOErr( int errcode, ... ) { //================================= // Handle a run time i/o error. char errbuff[ERR_BUFF_SIZE+1]; va_list args; va_start( args, errcode ); if( ( IOCB->set_flags & (SET_IOSPTR|SET_ERRSTMT) ) == 0 ) { if( errcode == IO_FILE_PROBLEM ) { GetIOErrMsg( IOCB->fileinfo, errbuff ); SysIOErr( errcode, errbuff ); } else { ErrHandler( errcode, args ); } } else { errcode = ErrCodOrg( errcode ); if( IOCB->fileinfo != NULL ) { IOCB->fileinfo->error = errcode; } IOCB->status = errcode; } Suicide(); va_end( args ); }
void ErrorExit( const char *msg ) /*******************************/ { QWrite( STDERR_HANDLE, msg, strlen( msg ), "console" ); QWriteNL( STDERR_HANDLE, "console" ); Suicide(); }
void Error( char * msg ) /**********************/ { put( "Error: " ); put( msg ); put( "\n" ); Suicide(); }
static void ProcHelp( const char *arg ) /*************************************/ { arg=arg; WriteHelp(); WriteOptions( OptionsTable ); Suicide(); }
void CheckErr( void ) /**************************/ { if( LinkState & ( LINK_ERROR | STOP_WORKING ) ) { WriteLibsUsed(); Suicide(); } }
void IOError( char *msg ) /***********************/ { put( msg ); put( ": " ); put( strerror( errno ) ); put( "\n" ); Suicide(); }
static void ProcHelp( const char *arg ) /*************************************/ { /* unused parameters */ (void)arg; WriteHelp(); WriteOptions( OptionsTable ); Suicide(); }
static void FreeIOErr( uint err ) { //===================================== // Report error during list-directed or NAMELIST-directed i/o. if( IOCB->flags & NML_DIRECTED ) { IOCB->flags |= NML_CONTINUE; Suicide(); } IOErr( err ); }
/* Here we save the signal state of the user process. This is called * when we are checkpointing. */ void _condor_save_sigstates() { sigset_t mask; int scm; int sig; /* First, save the user's signal mask. This must happen before we modify it in any way. */ sigprocmask(0,0,&signal_states.user_mask); /* Disable handing of user-mode signal handlers. This prevents any signal handlers from getting called in local unmapped mode. */ sigfillset(&mask); sigprocmask(SIG_SETMASK,&mask,0); /* Switch to local unmapped mode. This msut happen _after_ blocking user signal handlers */ scm = SetSyscalls( SYS_LOCAL | SYS_UNRECORDED ); /* Now, disable signal handling _again_. This prevents checkpointing signals from interrupting us while checkpointing */ sigfillset(&mask); sigprocmask(SIG_SETMASK,&mask,0); /* Save pending signal information */ sigpending( &(signal_states.pending) ); if ( signal_states.nsigs == 0 ) { #if !SIGISMEMBER_IS_BROKEN /* This code only runs once; here we figure out how many signals * this OS supports and verify our array (of size NUM_SIGS) is * big enough to store all the state. */ sigfillset(&mask); sig = 1; while ( sigismember(&mask,sig) > 0 ) sig++; signal_states.nsigs = sig; if ( sig > NUM_SIGS ) { dprintf( D_ALWAYS, "must recompile to support %d signals; current max=%d\n", sig, NUM_SIGS); Suicide(); } #else signal_states.nsigs = NUM_SIGS; #endif } /* Save handler information for each signal */ for ( sig=1; sig < signal_states.nsigs; sig++ ) { sigaction(sig,NULL,&(signal_states.actions[sig])); } (void) SetSyscalls( scm ); }
static void ProcFile( char * fname ) /**********************************/ { int ftype; char * name; int status; int namelen; char * bak; namelen = strlen( fname ) + 5; name = alloca( namelen ); if( name == NULL ) Suicide(); // null == no stack space left. strcpy( name, fname ); ReplaceExt( name, ".obj", FALSE ); InFile = QOpen( name, O_RDONLY | O_BINARY, 0 ); for(;;) { CleanRecStuff(); ftype = ReadRec(); if( ftype == ENDLIBRARY || ftype == ENDFILE ) { break; } else if( ftype == LIBRARY ) { Warning( "exclude option does not apply to libraries" ); FreeList( ExcludeList ); ExcludeList = NULL; } else if( ftype != OBJECT ) { Error( "file is not a standard OBJECT or LIBRARY file" ); } OutFile = QOpen( TEMP_OBJ_NAME, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0 ); do { ProcessRec(); status = ReadRec(); } while( status == OK ); if( status == ENDMODULE ) { ProcessRec(); // process the modend rec. DoReplace(); } else { Error( "premature end of file encountered" ); } FreeList( ExcludeList ); // do this here so concatenated .obj files ExcludeList = NULL; // only have the first module excluded. } CloseFiles(); if( MakeBackup ) { bak = alloca( namelen ); if( bak == NULL ) Suicide(); // null == no stack space left. strcpy( bak, name ); if( ftype == ENDLIBRARY ) { ReplaceExt( bak, ".bak", TRUE ); } else { ReplaceExt( bak, ".bob", TRUE ); } CopyFile( name, bak ); } QRemove( name ); if( ftype == ENDLIBRARY ) { rename( TEMP_LIB_NAME, name ); } else { rename( TEMP_OBJ_NAME, name ); } FileCleanup(); }
void Robot::Action() { switch (GetType()) { case Left: if (!startattack) { if (!trigger) { if (coretype != Eternity) { HGE *hge = hgeCreate(HGE_VERSION); float x, y; hge->Input_GetMousePos(&x, &y); int dis = GetDistance(x, y); if (dis < 20) { if (hge->Input_KeyDown(HGEK_LBUTTON)) { trigger = true; backx = GetX(); backy = GetY(); } else { if (hge->Input_KeyDown(HGEK_RBUTTON)) Suicide(true); } } } } else { ObjectPool::GetObjPool().LockOnGameObject(this); if (runback) { if (GoToAnotherPos(backx,backy)) { trigger = false; runback = false; SetSpeed(0); } } else { HGE *hge = hgeCreate(HGE_VERSION); float x, y; hge->Input_GetMousePos(&x, &y); SetPos(x, y); if (hge->Input_KeyUp(HGEK_LBUTTON)) { if (x<ACT_START_X || x>ACT_END_X || y<ACT_START_Y || y>ACT_END_Y) { runback = true; SetSpeed(1200); } else { switch (coretype) { //攻击型 //开始攻击 case Attack: SetCollisionRange(40); SetSolid(true); SetBlock(true); break; //触发技能型 //跟hero做intercation将自身赋给hero然后自杀 case Magic: dynamic_cast<Hero*>(ObjectPool::GetObjPool().GetOurHero(GetType()))->SetSkill(GetInnerCode() + 300); Suicide(); break; //BUFF型 //施放技能 case Buff: { int count = 0; Hero *a = dynamic_cast<Hero*>(ObjectPool::GetObjPool().GetOurHero(GetType())); for (int i = 0; i < STD_CORES; i++) { Robot *b = dynamic_cast<Robot*>(a->GetCOREs(i)); if (b && b->IsActive()) { if (b->GetInnerCode() == GetInnerCode()) { b->Suicide(); a->Interaction(b); } else if (b->GetCoreType() == Buff) count++; } } SetSpeed(1500); SetAim(25+count * 50, 175); } break; } startattack = true; } } } } } else { switch (coretype) { case Attack: if (GetAim()) GetAngle(GetAim()); if (shootdelay) shootdelay--; else { if (!GetAim()) SetAim(ObjectPool::GetObjPool().GetRandomEnemyUnit(GetType())); else { Skill *skill = new Skill(this, CORESKILL); ObjectPool::GetObjPool().InsertObject(skill, true); } shootdelay = std_shootdelay; } break; case Buff: if (GoToAim()) { if (!buffstart) { ObjectPool::GetObjPool().GetOurHero(GetType())->Interaction(this); buffstart = true; } if (shootdelay) shootdelay--; else { Suicide(); if (host) host->Interaction(this); } } break; } HGE *hge = hgeCreate(HGE_VERSION); if (hge->Input_KeyDown(HGEK_RBUTTON)) { float x, y; hge->Input_GetMousePos(&x, &y); if (GetDistance(backx, backy, x, y) < 20) { Suicide(true); } } } break; case None: if (!GetSpeed()) { HGE *hge = hgeCreate(HGE_VERSION); float x, y; hge->Input_GetMousePos(&x, &y); int dis = GetDistance(x, y); if (dis < 50) { ObjectPool::GetObjPool().GetEnemyHero(GetType())->Scilence(); if (dis < 40) { if (hge->Input_KeyDown(HGEK_LBUTTON)) ObjectPool::GetObjPool().GetEnemyHero(GetType())->Interaction(this); else { if (hge->Input_KeyDown(HGEK_RBUTTON)) { Suicide(true); tremble = 0; } } } } else ObjectPool::GetObjPool().GetEnemyHero(GetType())->UnScilence(); } else ObjectPool::GetObjPool().GetEnemyHero(GetType())->UnScilence(); break; } if (tremble) { tremble--; int a = tremble / 5; int b = tremble % 5; if (a % 2) SetX(GetX() + (3 - b) * 2); else SetX(GetX() - (3 - b) * 2); } }
void Error( dbg_err_flags flg, char *fmt, ... ) { char buff[TXT_LEN]; va_list args; char *ptr; invokes *inv; input_stack *inp; char *where; bool cmderror; va_start( args, fmt ); ptr = buff; if( flg & ERR_INTERNAL ) { ptr = StrCopy( LIT_ENG( Internal_Error ), ptr ); } ptr = FmtStr( ptr, fmt, args ); ptr = StrCopy( ".", ptr ); if( flg & ERR_LOC ) { ptr = StrCopy( "\n ", ptr ); switch( CurrToken ) { case T_CMD_SEPARATOR: ptr = StrCopy( LIT_ENG( ERR_NEAR_END_OF_COMMAND ), ptr ); break; case T_LINE_SEPARATOR: ptr = StrCopy( LIT_ENG( ERR_NEAR_END_OF_LINE ), ptr ); break; default: if( ScanLen() == 0 ) Scan(); ptr = Format( ptr, LIT_ENG( ERR_NEAR_TOKEN ), ScanPos(), ScanLen() ); break; } } SetProgStartHook( TRUE ); UnFreezeRegs(); ScanExpr( NULL ); ExprPurge(); PurgeSymHandles(); /* must be done after ExprPurge */ DIPCancel(); ScanSavePtr = 0; /* clean up previous ScanSave locations */ if( _IsOff( SW_ERROR_PRESERVES_RADIX ) ) { RestoreRadix(); } _SwitchOff( SW_CALL_FATAL ); if( _IsOn( SW_ERROR_STARTUP ) ) { StartupErr( buff ); } if( _IsOn( SW_ERR_IN_TXTBUFF ) ) { PurgeInpStack(); StrCopy( buff, TxtBuff ); DUIArrowCursor(); Suicide(); } if( (flg & ERR_SILENT) == 0 ) { where = LIT_ENG( ERR_EXECUTING_AT ); for( inp = InpStack; inp != NULL; inp = inp->link ) { if( inp->type & INP_CMD_FILE ) { inv = inp->handle; ptr = StrCopy( "\n ", ptr ); ptr = Format( ptr, where, inv->line, inv->name ); where = LIT_ENG( ERR_CALLED_FROM ); } } DUIFlushKeys(); DUIWndDebug(); RingBell(); DUIErrorBox( buff ); } cmderror = FALSE; for( inp = InpStack; inp != NULL; inp = inp->link ) { if( inp->type & INP_BREAK_POINT ) { BrkCmdError(); } if( inp->type & INP_CAPTURED ) { CaptureError(); } if( inp->type & INP_DLG_CMD ) { cmderror = TRUE; } } PurgeInpStack(); if( cmderror && fmt != LIT_ENG( ERR_DBG_INTERRUPT ) ) { DlgCmd(); ProcInput(); } if( _IsOn( SW_ERROR_RETURNS ) ) return; DUIArrowCursor(); Suicide(); }
void DoCmdFile( char *fname ) /**********************************/ /* start parsing the command */ { exe_format possible; f_handle file; size_t namelen; file_defext extension; char *namelnk; ResetCmdFile(); if( fname == NULL || *fname == '\0' ) { _ChkAlloc( fname, (10*1024) ); // arbitrarily large buffer that won't GetCmdLine( fname ); // be overflowed NewCommandSource( NULL, fname, COMMANDLINE ); } else { NewCommandSource( NULL, fname, ENVIRONMENT ); } if( IsStdOutConsole() ) { CmdFlags |= CF_TO_STDOUT; } while( *fname == ' ' ) { fname++; } if( QSysHelp( &Token.next ) ) { Help(); } if( *fname == '?' ) { Token.next = fname + 1; // skip question mark. Help(); #if defined( __UNIX__ ) } else if( *fname == '-' ) { #else } else if( *fname == '-' || *fname == '/' ) { #endif if( *(fname + 1) == '?' ) { Token.next = fname + 2; // skip /? Help(); } } if( *fname == '\0' ) { // go into interactive mode. Token.how = INTERACTIVE; Token.where = ENDOFLINE; LnkMsg( INF+MSG_PRESS_CTRL_Z, NULL ); } namelnk = GetEnvString( INIT_FILE_ENV ); file = ( namelnk != NULL ) ? FindPath( namelnk ) : NIL_FHANDLE; if( file == NIL_FHANDLE ) { namelnk = INIT_FILE_NAME; file = FindPath( namelnk ); } if( file != NIL_FHANDLE ) { fname = ChkStrDup( namelnk ); SetCommandFile( file, fname ); } if( Spawn( DoCmdParse ) ) { Ignite(); Suicide(); } GetExtraCommands(); if( !(LinkState & FMT_DECIDED) ) { /* restrict set to automatically decided ones */ #if defined( __QNX__ ) #define LAST_CHANCE ( MK_OS2_LX | MK_OS2_LE | MK_OS2_NE | MK_QNX ) #elif defined( __LINUX__ ) #define LAST_CHANCE ( MK_OS2_LX | MK_OS2_LE | MK_OS2_NE | MK_ELF ) #elif defined( __NT__ ) #define LAST_CHANCE ( MK_OS2_LX | MK_OS2_NE | MK_WINDOWS | MK_PE | MK_DOS_EXE | MK_WIN_VXD ) #else #define LAST_CHANCE ( MK_OS2_LX | MK_OS2_LE | MK_OS2_NE | MK_DOS_EXE | MK_PHAR_SIMPLE ) #endif HintFormat( LAST_CHANCE ); } else { /* restrict to a unique type */ for( possible = 1; possible != 0; possible *= 2 ) { if( FmtData.type & possible ) { FmtData.type = possible; break; } } } if( (FmtData.type & (MK_NOVELL | MK_DOS)) && (LinkFlags & INC_LINK_FLAG) ) { LnkMsg( FTL+MSG_FORMAT_BAD_OPTION, "s", "incremental" ); } #ifdef _NOVELL if( FmtData.type & MK_NOVELL ) { CmdNovFini(); } else #endif if( FmtData.type & MK_OVERLAYS ) { CmdOvlFini(); AddObjLib( "wovl.lib", LIB_PRIORITY_MIN ); // add a reference to wovl.lib } if( Name == NULL || !(CmdFlags & CF_HAVE_FILES) ) { Ignite(); LnkMsg( FTL+MSG_NO_FILES_FOUND, NULL ); } namelen = strlen( Name ); if( MapFlags & MAP_FLAG ) { if( MapFName == NULL ) { MapFName = FileName( Name, namelen, E_MAP, TRUE ); } } else { MapFlags = 0; // if main isn't set, don't set anything. } if( SymFileName == NULL && ( (CmdFlags & CF_SEPARATE_SYM) || (LinkFlags & OLD_DBI_FLAG) && (FmtData.type & MK_COM) ) ) { SymFileName = FileName( Name, namelen, E_SYM, TRUE ); } if( FmtData.make_implib && FmtData.implibname == NULL ) { if( FmtData.make_impfile ) { extension = E_LBC; } else { extension = E_LIBRARY; } FmtData.implibname = FileName( Name, namelen, extension, TRUE ); } CheckTraces(); BurnUtils(); PruneSystemList(); NumberSections(); DBIInit(); }
int IOMain( void (*io_rtn)( void ) ) { //================================== int io_stmt; int io_stat; // turn of IOF_SETIOCB so that we can detect "i/o already active" - by // the time we call IOMain(), no one should be checking IOF_SETIOCB IOCB->flags &= ~IOF_SETIOCB; io_stmt = IOCB->iostmt; if( ( Spawn( io_rtn ) != 0 ) && ( IOCB->fileinfo != NULL ) && ( ( io_stmt == IO_READ ) || ( io_stmt == IO_WRITE ) ) ) { IOCB->fileinfo->col = 0; // so next statement starts new record if( ( io_stmt == IO_READ ) && _LogicalRecordOrganization( IOCB->fileinfo ) ) { SkipLogicalRecord( IOCB->fileinfo ); } IOCB->fileinfo->flags &= ~FTN_LOGICAL_RECORD; // in case we got EOF if( IOCB->set_flags & SET_INTERNAL ) { DiscoFile( IOCB->fileinfo ); } } if( __XcptFlags & XF_IO_INTERRUPTED ) { RTErr( KO_INTERRUPT ); } if( __XcptFlags & XF_FATAL_ERROR ) { __ReleaseIOSys(); // so other threads can continue Suicide(); } io_stat = IOCB->status; if( IOCB->set_flags & SET_IOSPTR ) { // set up IOSTAT *IOCB->iosptr = io_stat; } if( io_stat == 0 ) { while( IOCB->typ != PT_NOTYPE ) { // flush the io list IOCB->typ = IOTypeRtn(); } } if( io_stmt == IO_READ ) { // Consider: READ( 1, *, END=10 ) // ... // 10 WRITE( 1, * ) 'write after EOF' // the record number got incremented, so if an EOF condition // was encounterd we must adjust the record number so that // we don't get IO_PAST_EOF on the write if( ( IOCB->set_flags & SET_INTERNAL ) == 0 ) { // Consider: READ(5,*,IOSTAT=IOS) I // READ(5,*) I // If the first read gets EOF, then we must clear eof before // doing the next read so that we don't get EOF again. // Note: This is to be done only for files that don't have an // EOF (like TERMINAL). ClearEOF(); } } #if defined( __MT__ ) && !defined( _SA_LIBRARY ) // we cannot release the i/o system for READ/WRITE statements since // co-routines are not done yet if( (io_stmt != IO_READ) && (io_stmt != IO_WRITE) ) #endif __ReleaseIOSys(); __XcptFlags &= ~XF_IO_INTERRUPTABLE; return( io_stat ); }
void DebugExit( void ) { if( DUIClose() ) { Suicide(); } }