hello world

neo/tools/debugger/DebuggerServer.cpp

@@ -0,0 +1,714 @@
+/*
+===========================================================================
+
+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 );
+}