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
|
using System;
using Mono.Debugger.Backend;
using System.Runtime.Serialization;
using System.Xml;
namespace Mono.Debugger
{
[Serializable]
public enum HardwareWatchType {
WatchRead,
WatchWrite
}
// <summary>
// This is an abstract base class which is implemented by the user interface to
// hold the user's settings for a breakpoint.
// </summary>
public abstract class Breakpoint : Event
{
internal abstract BreakpointHandle Resolve (Thread target, StackFrame frame);
public virtual bool HideFromUser {
get { return false; }
}
public override void Remove (Thread target)
{
Deactivate (target);
}
// <summary>
// Internal breakpoint handler.
// </summary>
// <remarks>
// The return value specifies whether we already dealt with the breakpoint; so you
// normally make it return `true' when overriding.
// </remarks>
internal virtual bool BreakpointHandler (Inferior inferior, out bool remain_stopped)
{
remain_stopped = false;
return false;
}
// <summary>
// This method is called each time the breakpoint is hit.
// It returns true if the target should remain stopped and false
// if the breakpoint is to be ignored.
// </summary>
// <remarks>
// The @target argument is *not* serializable and may not be used
// anywhere outside this handler.
// </remarks>
public virtual bool CheckBreakpointHit (Thread target, TargetAddress address)
{
return true;
}
public override string ToString ()
{
return String.Format ("{0} ({1}:{2})", GetType (), Index, Name);
}
protected Breakpoint (EventType type, string name, ThreadGroup group)
: base (type, name, group)
{ }
protected Breakpoint (EventType type, int index, string name, ThreadGroup group)
: base (type, index, name, group)
{ }
protected static EventType GetEventType (HardwareWatchType type)
{
switch (type) {
case HardwareWatchType.WatchRead:
return EventType.WatchRead;
case HardwareWatchType.WatchWrite:
return EventType.WatchWrite;
default:
throw new InternalError ();
}
}
}
}
|
