DebuggerClient.h

Go to the documentation of this file.

/*
===========================================================================

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.

===========================================================================
*/
#ifndef DEBUGGERCLIENT_H_
#define DEBUGGERCLIENT_H_

class rvDebuggerCallstack
{
public:

        idStr   mFilename;
        int             mLineNumber;
        idStr   mFunction;
};

class rvDebuggerThread
{
public:

        idStr   mName;
        int             mID;
        bool    mCurrent;
        bool    mDying;
        bool    mWaiting;
        bool    mDoneProcessing;
};

#ifndef DEBUGGERBREAKPOINT_H_
#include "DebuggerBreakpoint.h"
#endif

typedef idList<rvDebuggerCallstack*>    rvDebuggerCallstackList;
typedef idList<rvDebuggerThread*>               rvDebuggerThreadList;
typedef idList<rvDebuggerBreakpoint*>   rvDebuggerBreakpointList;

class rvDebuggerClient
{
public:

        rvDebuggerClient ( );
        ~rvDebuggerClient ( );

        bool                                            Initialize                              ( void );
        void                                            Shutdown                                ( void );
        bool                                            ProcessMessages                 ( void );
        bool                                            WaitFor                                 ( EDebuggerMessage msg, int time );
        
        bool                                            IsConnected                             ( void );
        bool                                            IsStopped                               ( void );
        
        int                                                     GetActiveBreakpointID   ( void );
        const char*                                     GetBreakFilename                ( void );
        int                                                     GetBreakLineNumber              ( void );
        rvDebuggerCallstackList&        GetCallstack                    ( void );
        rvDebuggerThreadList&           GetThreads                              ( void );
        const char*                                     GetVariableValue                ( const char* name, int stackDepth );
        
        void                                            InspectVariable                 ( const char* name, int callstackDepth );
        
        void                                            Break                                   ( void );
        void                                            Resume                                  ( void );
        void                                            StepInto                                ( void );
        void                                            StepOver                                ( void );

        // Breakpoints
        int                                                     AddBreakpoint                   ( const char* filename, int lineNumber, bool onceOnly = false );
        bool                                            RemoveBreakpoint                ( int bpID );
        void                                            ClearBreakpoints                ( void );
        int                                                     GetBreakpointCount              ( void );
        rvDebuggerBreakpoint*           GetBreakpoint                   ( int index );
        rvDebuggerBreakpoint*           FindBreakpoint                  ( const char* filename, int linenumber );
                
protected:

        void                                            SendMessage                             ( EDebuggerMessage dbmsg );
        void                                            SendBreakpoints                 ( void );
        void                                            SendAddBreakpoint               ( rvDebuggerBreakpoint& bp, bool onceOnly = false );
        void                                            SendRemoveBreakpoint    ( rvDebuggerBreakpoint& bp );
        void                                            SendPacket                              ( void* data, int datasize );

        bool                                            mConnected;
        netadr_t                                        mServerAdr;
        idPort                                          mPort;
        
        bool                                            mBreak;
        int                                                     mBreakID;
        int                                                     mBreakLineNumber;
        idStr                                           mBreakFilename;
        
        idDict                                          mVariables;

        rvDebuggerCallstackList         mCallstack;
        rvDebuggerThreadList            mThreads;       
        rvDebuggerBreakpointList        mBreakpoints;

        EDebuggerMessage                        mWaitFor;
        
private:

        void            ClearCallstack                          ( void );
        void            ClearThreads                            ( void );
        
        void            UpdateWatches                           ( void );
        
        // Network message handlers
        void            HandleBreak                                     ( msg_t* msg );
        void            HandleInspectCallstack          ( msg_t* msg );
        void            HandleInspectThreads            ( msg_t* msg );
        void            HandleInspectVariable           ( msg_t* msg );
};

/*
================
rvDebuggerClient::IsConnected
================
*/
ID_INLINE bool rvDebuggerClient::IsConnected ( void )
{
        return mConnected;
}

/*
================
rvDebuggerClient::IsStopped
================
*/
ID_INLINE bool rvDebuggerClient::IsStopped ( void )
{
        return mBreak;
}

/*
================
rvDebuggerClient::GetActiveBreakpointID
================
*/
ID_INLINE int rvDebuggerClient::GetActiveBreakpointID ( void )
{
        return mBreakID;
}

/*
================
rvDebuggerClient::GetBreakFilename
================
*/
ID_INLINE const char* rvDebuggerClient::GetBreakFilename ( void )
{
        return mBreakFilename;
}

/*
================
rvDebuggerClient::GetBreakLineNumber
================
*/
ID_INLINE int rvDebuggerClient::GetBreakLineNumber ( void )
{
        return mBreakLineNumber;
}

/*
================
rvDebuggerClient::GetCallstack
================
*/
ID_INLINE rvDebuggerCallstackList& rvDebuggerClient::GetCallstack ( void )
{
        return mCallstack;
}

/*
================
rvDebuggerClient::GetThreads
================
*/
ID_INLINE rvDebuggerThreadList& rvDebuggerClient::GetThreads ( void )
{
        return mThreads;
}

/*
================
rvDebuggerClient::GetVariableValue
================
*/
ID_INLINE const char* rvDebuggerClient::GetVariableValue ( const char* var, int stackDepth )
{
        return mVariables.GetString ( va("%d:%s",stackDepth,var), "" );
}

/*
================
rvDebuggerClient::GetBreakpointCount
================
*/
ID_INLINE int rvDebuggerClient::GetBreakpointCount ( void )
{
        return mBreakpoints.Num ( );
}

/*
================
rvDebuggerClient::GetBreakpoint
================
*/
ID_INLINE rvDebuggerBreakpoint* rvDebuggerClient::GetBreakpoint ( int index )
{
        return mBreakpoints[index];
}

/*
================
rvDebuggerClient::Break
================
*/
ID_INLINE void rvDebuggerClient::Break ( void )
{
        SendMessage ( DBMSG_BREAK );
}

/*
================
rvDebuggerClient::Resume
================
*/
ID_INLINE void rvDebuggerClient::Resume ( void )
{
        mBreak = false;
        SendMessage ( DBMSG_RESUME );
}

/*
================
rvDebuggerClient::StepOver
================
*/
ID_INLINE void rvDebuggerClient::StepOver ( void )
{
        mBreak = false;
        SendMessage ( DBMSG_STEPOVER );
}

/*
================
rvDebuggerClient::StepInto
================
*/
ID_INLINE void rvDebuggerClient::StepInto ( void )
{
        mBreak = false;
        SendMessage ( DBMSG_STEPINTO );
}

/*
================
rvDebuggerClient::SendPacket
================
*/
ID_INLINE void rvDebuggerClient::SendPacket ( void* data, int size )
{
        mPort.SendPacket ( mServerAdr, data, size );
}

#endif // DEBUGGERCLIENT_H_