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();
}
}
