File: debuggergdb.h

package info (click to toggle)
codelite 14.0+dfsg-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 112,816 kB
  • sloc: cpp: 483,662; ansic: 150,144; php: 9,569; lex: 4,186; python: 3,417; yacc: 2,820; sh: 1,147; makefile: 52; xml: 13
file content (177 lines) | stat: -rw-r--r-- 7,089 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// copyright            : (C) 2008 by Eran Ifrah
// file name            : debuggergdb.h
//
// -------------------------------------------------------------------------
// A
//              _____           _      _     _ _
//             /  __ \         | |    | |   (_) |
//             | /  \/ ___   __| | ___| |    _| |_ ___
//             | |    / _ \ / _  |/ _ \ |   | | __/ _ )
//             | \__/\ (_) | (_| |  __/ |___| | ||  __/
//              \____/\___/ \__,_|\___\_____/_|\__\___|
//
//                                                  F i l e
//
//    This program 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 2 of the License, or
//    (at your option) any later version.
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
#ifndef DBGINTERFACE_H
#define DBGINTERFACE_H

#include "wx/string.h"
#include "wx/event.h"
#include "list"
#include "debugger.h"
#include <wx/hashmap.h>
#include "consolefinder.h"
#include "cl_command_event.h"

#ifdef MSVC_VER
// declare the debugger function creation
extern "C++" IDebugger* CreateDebuggerGDB();
// declare the function that will be called by host application
// to retrieve the debugger initialization function
extern "C++" DebuggerInfo GetDebuggerInfo();
#else
// declare the debugger function creation
extern "C" IDebugger* CreateDebuggerGDB();
// declare the function that will be called by host application
// to retrieve the debugger initialization function
extern "C" DebuggerInfo GetDebuggerInfo();
#endif

class DbgCmdHandler;
class DbgCmdCLIHandler;
class IProcess;

typedef std::map<wxString, DbgCmdHandler*> HandlersMap_t;

extern const wxEventType wxEVT_GDB_STOP_DEBUGGER;

class DbgGdb : public wxEvtHandler, public IDebugger
{
    HandlersMap_t m_handlers;
    long m_debuggeePid;
    ConsoleFinder m_consoleFinder;
    std::vector<BreakpointInfo> m_bpList;
    DbgCmdCLIHandler* m_cliHandler;
    IProcess* m_gdbProcess;
    wxArrayString m_gdbOutputArr;
    wxString m_gdbOutputIncompleteLine;
    bool m_break_at_main;
    bool m_attachedMode;
    bool m_goingDown;
    bool m_reverseDebugging;
    wxStringSet_t m_reversableCommands;
    bool m_isRecording;

public:
    int m_internalBpId;

protected:
    void RegisterHandler(const wxString& id, DbgCmdHandler* cmd);
    DbgCmdHandler* PopHandler(const wxString& id);
    void EmptyQueue();
    bool FilterMessage(const wxString& msg);
    bool DoGetNextLine(wxString& line);
    void DoCleanup();

    // wrapper for convinience
    void DoProcessAsyncCommand(wxString& line, wxString& id);

protected:
    bool DoLocateGdbExecutable(const wxString& debuggerPath, wxString& dbgExeName);
    bool DoInitializeGdb(const DebugSessionInfo& sessionInfo);
    void SetCliHandler(DbgCmdCLIHandler* handler);
    DbgCmdCLIHandler* GetCliHandler();

public:
    bool WriteCommand(const wxString& command, DbgCmdHandler* cmd);
    bool ExecCLICommand(const wxString& command, DbgCmdCLIHandler* cmd);
    void SetBreakpoints();
    void SetInternalMainBpID(int bpId);
    void SetShouldBreakAtMain(bool break_at_main) { m_break_at_main = break_at_main; }
    bool GetShouldBreakAtMain() const { return m_break_at_main; }
    void GetDebugeePID(const wxString& line);

    void SetGoingDown(bool goingDown) { this->m_goingDown = goingDown; }
    bool IsGoingDown() const { return m_goingDown; }

    const std::vector<BreakpointInfo>& GetBpList() const { return m_bpList; }

    void SetIsRecording(bool isRecording) { this->m_isRecording = isRecording; }
    bool IsRecording() const { return m_isRecording; }

public:
    DbgGdb();
    virtual ~DbgGdb();

    //------ IDebugger ---------
    virtual bool Start(const DebugSessionInfo& si);
    virtual bool Attach(const DebugSessionInfo& si);
    virtual bool Run(const wxString& args, const wxString& comm);
    virtual bool Stop();
    virtual bool Break(const BreakpointInfo& bp);
    virtual bool SetEnabledState(double bid, const bool enable);
    virtual bool SetIgnoreLevel(double bid, const int ignorecount);
    virtual bool SetCondition(const BreakpointInfo& bp);
    virtual bool SetCommands(const BreakpointInfo& bp);
    virtual bool RemoveBreak(double bid);
    virtual bool RemoveAllBreaks();
    virtual bool StepIn();
    virtual bool StepInInstruction();
    virtual bool StepOut();
    virtual bool Next();
    virtual bool NextInstruction();
    virtual bool Continue();
    virtual bool QueryFileLine();
    virtual bool Disassemble(const wxString& filename, int lineNumber);
    virtual bool Interrupt();
    virtual bool IsRunning();
    virtual bool ExecuteCmd(const wxString& cmd);
    virtual bool EvaluateExpressionToString(const wxString& expression, const wxString& format);
    virtual bool QueryLocals();
    virtual bool ListFrames();
    virtual bool ListThreads();
    virtual bool SelectThread(long threadId);
    virtual bool SetFrame(int frame);
    virtual void Poke();
    virtual bool GetAsciiViewerContent(const wxString& dbgCommand, const wxString& expression);
    virtual bool ResolveType(const wxString& expression, int userReason);
    virtual bool WatchMemory(const wxString& address, size_t count, size_t columns);
    virtual bool SetMemory(const wxString& address, size_t count, const wxString& hex_value);
    virtual void SetDebuggerInformation(const DebuggerInformation& info);
    virtual void BreakList();
    virtual bool ListChildren(const wxString& name, int userReason);
    virtual bool CreateVariableObject(const wxString& expression, bool persistent, int userReason);
    virtual bool DeleteVariableObject(const wxString& name);
    virtual bool EvaluateVariableObject(const wxString& name, int userReason);
    virtual bool SetVariableObbjectDisplayFormat(const wxString& name, DisplayFormat displayFormat);
    virtual bool UpdateVariableObject(const wxString& name, int userReason);
    virtual void AssignValue(const wxString& expression, const wxString& newValue);
    virtual bool Jump(wxString filename, int line);
    virtual bool ListRegisters();
    virtual bool UpdateWatch(const wxString& name);
    virtual void EnableReverseDebugging(bool b);
    virtual void EnableRecording(bool b);
    virtual bool IsReverseDebuggingEnabled() const;
    
    /**
     * @brief restart the debugger (execute 'run')
     * @return true on success, false otherwise
     */
    virtual bool Restart();

    // Event handlers
    void OnProcessEnd(clProcessEvent& e);
    void OnDataRead(clProcessEvent& e);
    void OnKillGDB(wxCommandEvent& e);
};
#endif // DBGINTERFACE_H