715 lines
18 KiB
C++
715 lines
18 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "../../game/gamesys/Event.h"
|
|
#include "../../game/gamesys/Class.h"
|
|
#include "../../game/script/Script_Program.h"
|
|
#include "../../game/script/Script_Interpreter.h"
|
|
#include "../../game/script/Script_Thread.h"
|
|
#include "../../game/script/Script_Compiler.h"
|
|
#include "../../framework/sync/Msg.h"
|
|
#include "DebuggerApp.h"
|
|
#include "DebuggerServer.h"
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::rvDebuggerServer
|
|
================
|
|
*/
|
|
rvDebuggerServer::rvDebuggerServer ( )
|
|
{
|
|
mConnected = false;
|
|
mBreakNext = false;
|
|
mBreak = false;
|
|
mBreakStepOver = false;
|
|
mBreakStepInto = false;
|
|
mGameThread = NULL;
|
|
mLastStatementLine = -1;
|
|
mBreakStepOverFunc1 = NULL;
|
|
mBreakStepOverFunc2 = NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::~rvDebuggerServer
|
|
================
|
|
*/
|
|
rvDebuggerServer::~rvDebuggerServer ( )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::Initialize
|
|
|
|
Initialize the debugger server. This function should be called before the
|
|
debugger server is used.
|
|
================
|
|
*/
|
|
bool rvDebuggerServer::Initialize ( void )
|
|
{
|
|
// Initialize the network connection
|
|
if ( !mPort.InitForPort ( 27980 ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Get a copy of the game thread handle so we can suspend the thread on a break
|
|
DuplicateHandle ( GetCurrentProcess(), GetCurrentThread ( ), GetCurrentProcess(), &mGameThread, 0, FALSE, DUPLICATE_SAME_ACCESS );
|
|
|
|
// Create a critical section to ensure that the shared thread
|
|
// variables are protected
|
|
InitializeCriticalSection ( &mCriticalSection );
|
|
|
|
// Server must be running on the local host on port 28980
|
|
Sys_StringToNetAdr ( "localhost", &mClientAdr, true );
|
|
mClientAdr.port = 27981;
|
|
|
|
// Attempt to let the server know we are here. The server may not be running so this
|
|
// message will just get ignored.
|
|
SendMessage ( DBMSG_CONNECT );
|
|
|
|
return true;
|
|
}
|
|
|
|
void rvDebuggerServer::OSPathToRelativePath( const char *osPath, idStr &qpath )
|
|
{
|
|
if ( strchr( osPath, ':' ) )
|
|
{
|
|
qpath = fileSystem->OSPathToRelativePath( osPath );
|
|
}
|
|
else
|
|
{
|
|
qpath = osPath;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::Shutdown
|
|
|
|
Shutdown the debugger server.
|
|
================
|
|
*/
|
|
void rvDebuggerServer::Shutdown ( void )
|
|
{
|
|
// Let the debugger client know we are shutting down
|
|
if ( mConnected )
|
|
{
|
|
SendMessage ( DBMSG_DISCONNECT );
|
|
mConnected = false;
|
|
}
|
|
|
|
mPort.Close();
|
|
|
|
// dont need the crit section anymore
|
|
DeleteCriticalSection ( &mCriticalSection );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::ProcessMessages
|
|
|
|
Process all incoming network messages from the debugger client
|
|
================
|
|
*/
|
|
bool rvDebuggerServer::ProcessMessages ( void )
|
|
{
|
|
netadr_t adrFrom;
|
|
msg_t msg;
|
|
byte buffer[MAX_MSGLEN];
|
|
|
|
MSG_Init( &msg, buffer, sizeof( buffer ) );
|
|
|
|
// Check for pending udp packets on the debugger port
|
|
while ( mPort.GetPacket ( adrFrom, msg.data, msg.cursize, msg.maxsize ) )
|
|
{
|
|
unsigned short command;
|
|
|
|
// Only accept packets from the debugger server for security reasons
|
|
if ( !Sys_CompareNetAdrBase ( adrFrom, mClientAdr ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
command = (unsigned short) MSG_ReadShort ( &msg );
|
|
|
|
switch ( command )
|
|
{
|
|
case DBMSG_CONNECT:
|
|
mConnected = true;
|
|
SendMessage ( DBMSG_CONNECTED );
|
|
break;
|
|
|
|
case DBMSG_CONNECTED:
|
|
mConnected = true;
|
|
break;
|
|
|
|
case DBMSG_DISCONNECT:
|
|
ClearBreakpoints ( );
|
|
Resume ( );
|
|
mConnected = false;
|
|
break;
|
|
|
|
case DBMSG_ADDBREAKPOINT:
|
|
HandleAddBreakpoint ( &msg );
|
|
break;
|
|
|
|
case DBMSG_REMOVEBREAKPOINT:
|
|
HandleRemoveBreakpoint ( &msg );
|
|
break;
|
|
|
|
case DBMSG_RESUME:
|
|
Resume ( );
|
|
break;
|
|
|
|
case DBMSG_BREAK:
|
|
mBreakNext = true;
|
|
break;
|
|
|
|
case DBMSG_STEPOVER:
|
|
mBreakStepOver = true;
|
|
mBreakStepOverDepth = mBreakInterpreter->GetCallstackDepth ( );
|
|
mBreakStepOverFunc1 = mBreakInterpreter->GetCallstack()[mBreakInterpreter->GetCallstackDepth()].f;
|
|
if ( mBreakInterpreter->GetCallstackDepth() > 0 )
|
|
{
|
|
mBreakStepOverFunc2 = mBreakInterpreter->GetCallstack()[mBreakInterpreter->GetCallstackDepth()-1].f;
|
|
}
|
|
else
|
|
{
|
|
mBreakStepOverFunc2 = NULL;
|
|
}
|
|
Resume ( );
|
|
break;
|
|
|
|
case DBMSG_STEPINTO:
|
|
mBreakStepInto = true;
|
|
Resume ( );
|
|
break;
|
|
|
|
case DBMSG_INSPECTVARIABLE:
|
|
HandleInspectVariable ( &msg );
|
|
break;
|
|
|
|
case DBMSG_INSPECTCALLSTACK:
|
|
HandleInspectCallstack ( &msg );
|
|
break;
|
|
|
|
case DBMSG_INSPECTTHREADS:
|
|
HandleInspectThreads ( &msg );
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::SendMessage
|
|
|
|
Send a message with no data to the debugger server.
|
|
================
|
|
*/
|
|
void rvDebuggerServer::SendMessage ( EDebuggerMessage dbmsg )
|
|
{
|
|
msg_t msg;
|
|
byte buffer[MAX_MSGLEN];
|
|
|
|
MSG_Init( &msg, buffer, sizeof( buffer ) );
|
|
MSG_WriteShort ( &msg, (int)dbmsg );
|
|
|
|
SendPacket ( msg.data, msg.cursize );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::HandleAddBreakpoint
|
|
|
|
Handle the DBMSG_ADDBREAKPOINT message being sent by the debugger client. This
|
|
message is handled by adding a new breakpoint to the breakpoint list with the
|
|
data supplied in the message.
|
|
================
|
|
*/
|
|
void rvDebuggerServer::HandleAddBreakpoint ( msg_t* msg )
|
|
{
|
|
bool onceOnly = false;
|
|
long lineNumber;
|
|
long id;
|
|
char filename[MAX_PATH];
|
|
|
|
// Read the breakpoint info
|
|
onceOnly = MSG_ReadBits ( msg, 1 ) ? true : false;
|
|
lineNumber = MSG_ReadLong ( msg );
|
|
id = MSG_ReadLong ( msg );
|
|
|
|
MSG_ReadString ( msg, filename, MAX_PATH );
|
|
|
|
// Since breakpoints are used by both threads we need to
|
|
// protect them with a crit section
|
|
EnterCriticalSection ( &mCriticalSection );
|
|
mBreakpoints.Append ( new rvDebuggerBreakpoint ( filename, lineNumber, id ) );
|
|
LeaveCriticalSection ( &mCriticalSection );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::HandleRemoveBreakpoint
|
|
|
|
Handle the DBMSG_REMOVEBREAKPOINT message being sent by the debugger client. This
|
|
message is handled by removing the breakpoint that matches the given id from the
|
|
list.
|
|
================
|
|
*/
|
|
void rvDebuggerServer::HandleRemoveBreakpoint ( msg_t* msg )
|
|
{
|
|
int i;
|
|
int id;
|
|
|
|
// ID that we are to remove
|
|
id = MSG_ReadLong ( msg );
|
|
|
|
// Since breakpoints are used by both threads we need to
|
|
// protect them with a crit section
|
|
EnterCriticalSection ( &mCriticalSection );
|
|
|
|
// Find the breakpoint that matches the given id and remove it from the list
|
|
for ( i = 0; i < mBreakpoints.Num(); i ++ )
|
|
{
|
|
if ( mBreakpoints[i]->GetID ( ) == id )
|
|
{
|
|
delete mBreakpoints[i];
|
|
mBreakpoints.RemoveIndex ( i );
|
|
break;
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection ( &mCriticalSection );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::MSG_WriteCallstackFunc
|
|
|
|
Writes a single callstack entry to the given message
|
|
================
|
|
*/
|
|
void rvDebuggerServer::MSG_WriteCallstackFunc ( msg_t* msg, const prstack_t* stack )
|
|
{
|
|
const statement_t* st;
|
|
const function_t* func;
|
|
|
|
func = stack->f;
|
|
|
|
// If the function is unknown then just fill in with default data.
|
|
if ( !func )
|
|
{
|
|
MSG_WriteString ( msg, "<UNKNOWN>" );
|
|
MSG_WriteString ( msg, "<UNKNOWN>" );
|
|
MSG_WriteLong ( msg, 0 );
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
MSG_WriteString ( msg, va("%s( ??? )", func->Name() ) );
|
|
}
|
|
|
|
// Use the calling statement as the filename and linenumber where
|
|
// the call was made from
|
|
st = &mBreakProgram->GetStatement ( stack->s );
|
|
if ( st )
|
|
{
|
|
idStr qpath;
|
|
OSPathToRelativePath(mBreakProgram->GetFilename( st->file ), qpath);
|
|
qpath.BackSlashesToSlashes ( );
|
|
MSG_WriteString ( msg, qpath );
|
|
MSG_WriteLong ( msg, st->linenumber );
|
|
}
|
|
else
|
|
{
|
|
MSG_WriteString ( msg, "<UNKNOWN>" );
|
|
MSG_WriteLong ( msg, 0 );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::HandleInspectCallstack
|
|
|
|
Handle an incoming inspect callstack message by sending a message
|
|
back to the client with the callstack data.
|
|
================
|
|
*/
|
|
void rvDebuggerServer::HandleInspectCallstack ( msg_t* in_msg )
|
|
{
|
|
msg_t msg;
|
|
byte buffer[MAX_MSGLEN];
|
|
int i;
|
|
prstack_t temp;
|
|
|
|
MSG_Init( &msg, buffer, sizeof( buffer ) );
|
|
MSG_WriteShort ( &msg, (int)DBMSG_INSPECTCALLSTACK );
|
|
|
|
MSG_WriteShort ( &msg, (int)mBreakInterpreter->GetCallstackDepth ( ) );
|
|
|
|
// write out the current function
|
|
temp.f = mBreakInterpreter->GetCurrentFunction ( );
|
|
temp.s = 0;
|
|
temp.stackbase = 0;
|
|
MSG_WriteCallstackFunc ( &msg, &temp );
|
|
|
|
// Run through all of the callstack and write each to the msg
|
|
for ( i = mBreakInterpreter->GetCallstackDepth ( ) - 1; i > 0; i -- )
|
|
{
|
|
MSG_WriteCallstackFunc ( &msg, mBreakInterpreter->GetCallstack ( ) + i );
|
|
}
|
|
|
|
SendPacket ( msg.data, msg.cursize );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::HandleInspectThreads
|
|
|
|
Send the list of the current threads in the interpreter back to the debugger client
|
|
================
|
|
*/
|
|
void rvDebuggerServer::HandleInspectThreads ( msg_t* in_msg )
|
|
{
|
|
msg_t msg;
|
|
byte buffer[MAX_MSGLEN];
|
|
int i;
|
|
|
|
// Initialize the message
|
|
MSG_Init( &msg, buffer, sizeof( buffer ) );
|
|
MSG_WriteShort ( &msg, (int)DBMSG_INSPECTTHREADS );
|
|
|
|
// Write the number of threads to the message
|
|
MSG_WriteShort ( &msg, (int)idThread::GetThreads().Num() );
|
|
|
|
// Loop through all of the threads and write their name and number to the message
|
|
for ( i = 0; i < idThread::GetThreads().Num(); i ++ )
|
|
{
|
|
idThread* thread = idThread::GetThreads()[i];
|
|
|
|
MSG_WriteString ( &msg, thread->GetThreadName ( ) );
|
|
MSG_WriteLong ( &msg, thread->GetThreadNum ( ) );
|
|
|
|
MSG_WriteBits ( &msg, (int)(thread == mBreakInterpreter->GetThread ( )), 1 );
|
|
MSG_WriteBits ( &msg, (int)thread->IsDoneProcessing(), 1 );
|
|
MSG_WriteBits ( &msg, (int)thread->IsWaiting(), 1 );
|
|
MSG_WriteBits ( &msg, (int)thread->IsDying(), 1 );
|
|
}
|
|
|
|
// Send off the inspect threads packet to the debugger client
|
|
SendPacket ( msg.data, msg.cursize );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::HandleInspectVariable
|
|
|
|
Respondes to a request from the debugger client to inspect the value of a given variable
|
|
================
|
|
*/
|
|
void rvDebuggerServer::HandleInspectVariable ( msg_t* in_msg )
|
|
{
|
|
char varname[256];
|
|
int scopeDepth;
|
|
|
|
if ( !mBreak )
|
|
{
|
|
return;
|
|
}
|
|
|
|
scopeDepth = (short)MSG_ReadShort ( in_msg );
|
|
MSG_ReadString ( in_msg, varname, 256 );
|
|
|
|
idStr varvalue;
|
|
|
|
msg_t msg;
|
|
byte buffer[MAX_MSGLEN];
|
|
|
|
// Initialize the message
|
|
MSG_Init( &msg, buffer, sizeof( buffer ) );
|
|
MSG_WriteShort ( &msg, (int)DBMSG_INSPECTVARIABLE );
|
|
|
|
if ( !mBreakInterpreter->GetRegisterValue ( varname, varvalue, scopeDepth ) )
|
|
{
|
|
varvalue = "???";
|
|
}
|
|
|
|
MSG_WriteShort ( &msg, (short)scopeDepth );
|
|
MSG_WriteString ( &msg, varname );
|
|
MSG_WriteString ( &msg, varvalue );
|
|
|
|
SendPacket ( msg.data, msg.cursize );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::CheckBreakpoints
|
|
|
|
Check to see if any breakpoints have been hit. This includes "break next",
|
|
"step into", and "step over" break points
|
|
================
|
|
*/
|
|
void rvDebuggerServer::CheckBreakpoints ( idInterpreter* interpreter, idProgram* program, int instructionPointer )
|
|
{
|
|
const statement_t* st;
|
|
const char* filename;
|
|
int i;
|
|
|
|
if ( !mConnected ) {
|
|
return;
|
|
}
|
|
|
|
// Grab the current statement and the filename that it came from
|
|
st = &program->GetStatement ( instructionPointer );
|
|
filename = program->GetFilename ( st->file );
|
|
|
|
// Operate on lines, not statements
|
|
if ( mLastStatementLine == st->linenumber && mLastStatementFile == st->file )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Save the last visited line and file so we can prevent
|
|
// double breaks on lines with more than one statement
|
|
mLastStatementFile = idStr( st->file );
|
|
mLastStatementLine = st->linenumber;
|
|
|
|
// Reset stepping when the last function on the callstack is returned from
|
|
if ( st->op == OP_RETURN && interpreter->GetCallstackDepth ( ) <= 1 )
|
|
{
|
|
mBreakStepOver = false;
|
|
mBreakStepInto = false;
|
|
}
|
|
|
|
// See if we are supposed to break on the next script line
|
|
if ( mBreakNext )
|
|
{
|
|
Break ( interpreter, program, instructionPointer );
|
|
return;
|
|
}
|
|
|
|
// Only break on the same callstack depth and thread as the break over
|
|
if ( mBreakStepOver )
|
|
{
|
|
if ( ( interpreter->GetCurrentFunction ( ) == mBreakStepOverFunc1 ||
|
|
interpreter->GetCurrentFunction ( ) == mBreakStepOverFunc2 )&&
|
|
( interpreter->GetCallstackDepth ( ) <= mBreakStepOverDepth ) )
|
|
{
|
|
Break ( interpreter, program, instructionPointer );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// See if we are supposed to break on the next line
|
|
if ( mBreakStepInto )
|
|
{
|
|
// Break
|
|
Break ( interpreter, program, instructionPointer );
|
|
return;
|
|
}
|
|
|
|
idStr qpath;
|
|
OSPathToRelativePath(filename,qpath);
|
|
qpath.BackSlashesToSlashes ( );
|
|
|
|
EnterCriticalSection ( &mCriticalSection );
|
|
|
|
// Check all the breakpoints
|
|
for ( i = 0; i < mBreakpoints.Num ( ); i ++ )
|
|
{
|
|
rvDebuggerBreakpoint* bp = mBreakpoints[i];
|
|
|
|
// Skip if not match of the line number
|
|
if ( st->linenumber != bp->GetLineNumber ( ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Skip if no match of the filename
|
|
if ( idStr::Icmp ( bp->GetFilename(), qpath ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Pop out of the critical section so we dont get stuck
|
|
LeaveCriticalSection ( &mCriticalSection );
|
|
|
|
// We hit a breakpoint, so break
|
|
Break ( interpreter, program, instructionPointer );
|
|
|
|
// Back into the critical section since we are going to have to leave it
|
|
EnterCriticalSection ( &mCriticalSection );
|
|
|
|
break;
|
|
}
|
|
|
|
LeaveCriticalSection ( &mCriticalSection );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::Break
|
|
|
|
Halt execution of the game threads and inform the debugger client that
|
|
the game has been halted
|
|
================
|
|
*/
|
|
void rvDebuggerServer::Break ( idInterpreter* interpreter, idProgram* program, int instructionPointer )
|
|
{
|
|
msg_t msg;
|
|
byte buffer[MAX_MSGLEN];
|
|
const statement_t* st;
|
|
const char* filename;
|
|
|
|
// Clear all the break types
|
|
mBreakStepOver = false;
|
|
mBreakStepInto = false;
|
|
mBreakNext = false;
|
|
|
|
// Grab the current statement and the filename that it came from
|
|
st = &program->GetStatement ( instructionPointer );
|
|
filename = program->GetFilename ( st->file );
|
|
|
|
idStr qpath;
|
|
OSPathToRelativePath(filename, qpath);
|
|
qpath.BackSlashesToSlashes ( );
|
|
|
|
// Give the mouse cursor back to the world
|
|
Sys_GrabMouseCursor( false );
|
|
|
|
// Set the break variable so we know the main thread is stopped
|
|
mBreak = true;
|
|
mBreakProgram = program;
|
|
mBreakInterpreter = interpreter;
|
|
mBreakInstructionPointer = instructionPointer;
|
|
|
|
// Inform the debugger of the breakpoint hit
|
|
MSG_Init( &msg, buffer, sizeof( buffer ) );
|
|
MSG_WriteShort ( &msg, (int)DBMSG_BREAK );
|
|
MSG_WriteLong ( &msg, st->linenumber );
|
|
MSG_WriteString ( &msg, qpath );
|
|
SendPacket ( msg.data, msg.cursize );
|
|
|
|
// Suspend the game thread. Since this will be called from within the main game thread
|
|
// execution wont return until after the thread is resumed
|
|
SuspendThread ( mGameThread );
|
|
|
|
// Let the debugger client know that we have started back up again
|
|
SendMessage ( DBMSG_RESUMED );
|
|
|
|
// This is to give some time between the keypress that
|
|
// told us to resume and the setforeground window. Otherwise the quake window
|
|
// would just flash
|
|
Sleep ( 150 );
|
|
|
|
// Bring the window back to the foreground
|
|
SetForegroundWindow ( win32.hWnd );
|
|
SetActiveWindow ( win32.hWnd );
|
|
UpdateWindow ( win32.hWnd );
|
|
SetFocus ( win32.hWnd );
|
|
|
|
// Give the mouse cursor back to the game
|
|
Sys_GrabMouseCursor( true );
|
|
|
|
// Clear all commands that were generated before we went into suspended mode. This is
|
|
// to ensure we dont have mouse downs with no ups because the context was changed.
|
|
idKeyInput::ClearStates();
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::Resume
|
|
|
|
Resume execution of the game.
|
|
================
|
|
*/
|
|
void rvDebuggerServer::Resume ( void )
|
|
{
|
|
// Cant resume if not paused
|
|
if ( !mBreak )
|
|
{
|
|
return;
|
|
}
|
|
|
|
mBreak = false;
|
|
|
|
// Start the game thread back up
|
|
ResumeThread ( mGameThread );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::ClearBreakpoints
|
|
|
|
Remove all known breakpoints
|
|
================
|
|
*/
|
|
void rvDebuggerServer::ClearBreakpoints ( void )
|
|
{
|
|
int i;
|
|
|
|
for ( i = 0; i < mBreakpoints.Num(); i ++ )
|
|
{
|
|
delete mBreakpoints[i];
|
|
}
|
|
|
|
mBreakpoints.Clear ( );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvDebuggerServer::Print
|
|
|
|
Sends a console print message over to the debugger client
|
|
================
|
|
*/
|
|
void rvDebuggerServer::Print ( const char* text )
|
|
{
|
|
if ( !mConnected )
|
|
{
|
|
return;
|
|
}
|
|
|
|
msg_t msg;
|
|
byte buffer[MAX_MSGLEN];
|
|
|
|
MSG_Init( &msg, buffer, sizeof( buffer ) );
|
|
MSG_WriteShort ( &msg, (int)DBMSG_PRINT );
|
|
MSG_WriteString ( &msg, text );
|
|
|
|
SendPacket ( msg.data, msg.cursize );
|
|
}
|