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
|
import { DebugProtocol } from "@vscode/debugprotocol";
import * as vscode from "vscode";
/** A helper type for mapping event types to their corresponding data type. */
// prettier-ignore
interface EventMap {
"module": DebugProtocol.ModuleEvent;
}
/** A type assertion to check if a ProtocolMessage is an event or if it is a specific event. */
function isEvent(
message: DebugProtocol.ProtocolMessage,
): message is DebugProtocol.Event;
function isEvent<K extends keyof EventMap>(
message: DebugProtocol.ProtocolMessage,
event: K,
): message is EventMap[K];
function isEvent(
message: DebugProtocol.ProtocolMessage,
event?: string,
): boolean {
return (
message.type === "event" &&
(!event || (message as DebugProtocol.Event).event === event)
);
}
/** Tracks lldb-dap sessions for data visualizers. */
export class DebugSessionTracker
implements vscode.DebugAdapterTrackerFactory, vscode.Disposable
{
/**
* Tracks active modules for each debug sessions.
*
* The modules are kept in an array to maintain the load order of the modules.
*/
private modules = new Map<vscode.DebugSession, DebugProtocol.Module[]>();
private modulesChanged = new vscode.EventEmitter<
vscode.DebugSession | undefined
>();
/**
* Fired when modules are changed for any active debug session.
*
* Use `debugSessionModules` to retieve the active modules for a given debug session.
*/
onDidChangeModules: vscode.Event<vscode.DebugSession | undefined> =
this.modulesChanged.event;
constructor() {
this.onDidChangeModules(this.moduleChangedListener, this);
vscode.debug.onDidChangeActiveDebugSession((session) =>
this.modulesChanged.fire(session),
);
}
dispose() {
this.modules.clear();
this.modulesChanged.dispose();
}
createDebugAdapterTracker(
session: vscode.DebugSession,
): vscode.ProviderResult<vscode.DebugAdapterTracker> {
return {
onDidSendMessage: (message) => this.onDidSendMessage(session, message),
onExit: () => this.onExit(session),
};
}
/**
* Retrieves the modules for the given debug session.
*
* Modules are returned in load order.
*/
debugSessionModules(session: vscode.DebugSession): DebugProtocol.Module[] {
return this.modules.get(session) ?? [];
}
/** Clear information from the active session. */
private onExit(session: vscode.DebugSession) {
this.modules.delete(session);
this.modulesChanged.fire(undefined);
}
private showModulesTreeView(showModules: boolean) {
vscode.commands.executeCommand(
"setContext",
"lldb-dap.showModules",
showModules,
);
}
private moduleChangedListener(session: vscode.DebugSession | undefined) {
if (!session) {
this.showModulesTreeView(false);
return;
}
if (session == vscode.debug.activeDebugSession) {
const sessionHasModules = this.modules.get(session) != undefined;
this.showModulesTreeView(sessionHasModules);
}
}
private onDidSendMessage(
session: vscode.DebugSession,
message: DebugProtocol.ProtocolMessage,
) {
if (isEvent(message, "module")) {
const { module, reason } = message.body;
const modules = this.modules.get(session) ?? [];
switch (reason) {
case "new":
case "changed": {
const index = modules.findIndex((m) => m.id === module.id);
if (index !== -1) {
modules[index] = module;
} else {
modules.push(module);
}
break;
}
case "removed": {
const index = modules.findIndex((m) => m.id === module.id);
if (index !== -1) {
modules.splice(index, 1);
}
break;
}
default:
console.error("unexpected module event reason");
break;
}
this.modules.set(session, modules);
this.modulesChanged.fire(session);
}
}
}
|
