File: clDebuggerBreakpoint.hpp

package info (click to toggle)
codelite 17.0.0%2Bdfsg-1
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 136,204 kB
  • sloc: cpp: 491,547; ansic: 280,393; php: 10,259; sh: 8,930; lisp: 7,664; vhdl: 6,518; python: 6,020; lex: 4,920; yacc: 3,123; perl: 2,385; javascript: 1,715; cs: 1,193; xml: 1,110; makefile: 804; cobol: 741; sql: 709; ruby: 620; f90: 566; ada: 534; asm: 464; fortran: 350; objc: 289; tcl: 258; java: 157; erlang: 61; pascal: 51; ml: 49; awk: 44; haskell: 36
file content (115 lines) | stat: -rw-r--r-- 3,995 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
#ifndef CLDEBUGGERBREAKPOINT_HPP
#define CLDEBUGGERBREAKPOINT_HPP

#include "JSON.h"
#include "codelite_exports.h"
#include "serialized_object.h"
#include <vector>
#include <wx/string.h>

// Breakpoint types. If you add more, clEditor::FillBPtoMarkerArray will also need altering
enum BreakpointType {
    /*Convenient return-codes*/
    BP_type_invalid = -1,
    BP_type_none = 0,
    /*Real breakpoint-types*/
    BP_FIRST_ITEM,
    BP_type_break = BP_FIRST_ITEM,
    BP_type_cmdlistbreak,
    BP_type_condbreak,
    BP_type_ignoredbreak,
    BP_type_tempbreak,
    BP_LAST_MARKED_ITEM = BP_type_tempbreak,
    BP_type_watchpt,
    BP_LAST_ITEM = BP_type_watchpt
};

// Watchpoint subtypes: write,read and both
enum WatchpointType { WP_watch, WP_rwatch, WP_awatch };

// The breakpoint origin:
// Can be from the Editor (user clicked 'F9')
// or from any other source (direct command to gdb, from the start up command etc)
enum BreakpointOrigin { BO_Editor, BO_Other };

class WXDLLIMPEXP_CL clDebuggerBreakpoint : public SerializedObject
{
public:
    typedef std::vector<clDebuggerBreakpoint> Vec_t;

public:
    // Where the bp is: file/lineno, function name (e.g. main()) or the memory location
    wxString file;
    int lineno = -1;
    wxString watchpt_data;
    wxString function_name;
    bool regex = false; // Is the function_name a regex?
    wxString memory_address;
    // How to identify the bp. Because the debugger won't always be running, we need an internal id as well as the
    // debugger's one
    double internal_id = wxNOT_FOUND;
    double debugger_id = wxNOT_FOUND; // -1 signifies not set
    BreakpointType bp_type =
        BP_type_break; // Is it a plain vanilla breakpoint, or a temporary one, or a watchpoint, or...
    size_t ignore_number =
        0; // 0 means 'not ignored'. >0 is the number of times the bp must be hit before it becomes enabled
    bool is_enabled = true;
    bool is_temp = false;
    WatchpointType watchpoint_type = WP_watch; // If this is a watchpoint, holds which sort it is
    wxString commandlist;
    wxString conditions;
    wxString at;
    wxString what;
    BreakpointOrigin origin = BO_Other;

    clDebuggerBreakpoint(const clDebuggerBreakpoint& BI);
    clDebuggerBreakpoint();
    clDebuggerBreakpoint& operator=(const clDebuggerBreakpoint& BI);
    ~clDebuggerBreakpoint();

    bool IsConditional()
    {
        return !conditions.IsEmpty();
    }
    double GetId() const
    {
        int best_id = (this->debugger_id == -1 ? this->internal_id : this->debugger_id);
        return best_id;
    }

    void Create(const wxString& filename, int line, int int_id, int ext_id = -1)
    {
        bp_type = BP_type_break;
        lineno = line;
        file = filename;
        internal_id = int_id;
        debugger_id = ext_id;
    }

    bool operator==(const clDebuggerBreakpoint& BI)
    {
        return ((origin == BI.origin) && (what == BI.what) && (at == BI.at) && (file == BI.file) &&
                (lineno == BI.lineno) && (function_name == BI.function_name) && (memory_address == BI.memory_address) &&
                (bp_type == BI.bp_type) && (watchpt_data == BI.watchpt_data) && (is_enabled == BI.is_enabled) &&
                (ignore_number == BI.ignore_number) && (conditions == BI.conditions) &&
                (commandlist == BI.commandlist) && (is_temp == BI.is_temp) &&
                (bp_type == BP_type_watchpt ? (watchpoint_type == BI.watchpoint_type) : true) &&
                (!function_name.IsEmpty() ? (regex == BI.regex) : true));
    }

    bool IsNull() const
    {
        return internal_id == wxNOT_FOUND && debugger_id == wxNOT_FOUND;
    }

    // JSON serialization
    JSONItem ToJSON() const;
    void FromJSON(const JSONItem& json);

protected:
    // SerializedObject interface
    virtual void Serialize(Archive& arch);
    virtual void DeSerialize(Archive& arch);
};
typedef std::vector<clDebuggerBreakpoint> clDebuggerBreakpointVec_t;
#endif // CLDEBUGGERBREAKPOINT_HPP