code-debug/src/backend/mi2/mi2inferior.ts at 8fd02d8aada161cc14fffb20d06a1a853b43f6ed · WebFreak001/code-debug · GitHub

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
import { Breakpoint, IBackend, SSHArguments, Stack, Thread, Variable } from "../backend";
import { MI2 } from "./mi2";

export class MI2Inferior implements IBackend {
	load(cwd: string, target: string, procArgs: string, separateConsole: string, autorun: string[]): Thenable<any> {
		return this.superior.load(cwd, target, procArgs, separateConsole, autorun);
	}

	ssh(args: SSHArguments, cwd: string, target: string, procArgs: string, separateConsole: string, attach: boolean, autorun: string[]): Thenable<any> {
		return this.superior.ssh(args, cwd, target, separateConsole, procArgs, attach, autorun);
	}

	attach(cwd: string, executable: string, target: string, autorun: string[]): Thenable<any> {
		return this.superior.attach(cwd, executable, target, autorun);
	}

	connect(cwd: string, executable: string, target: string, autorun: string[]): Thenable<any> {
		return this.superior.attach(cwd, executable, target, autorun);
	}

	start(runToStart: boolean): Thenable<boolean> {
		return this.superior.start(runToStart);
	}

	stop(): void {
		this.superior.stop();
	}

	detach(): void {
		this.superior.detach();
	}

	interrupt(threadId?: number): Thenable<boolean> {
		return this.superior.interrupt(threadId);
	}

	continue(reverse?: boolean, threadId?: number): Thenable<boolean> {
		return this.superior.continue(reverse, threadId);
	}

	next(): Thenable<boolean> {
		return this.superior.next();
	}
	step(): Thenable<boolean> {
		return this.superior.step();
	}

	stepOut(): Thenable<boolean> {
		return this.superior.stepOut();
	}

	loadBreakPoints(breakpoints: Breakpoint[]): Thenable<[boolean, Breakpoint][]> {
		return this.superior.loadBreakPoints(breakpoints);
	}

	addBreakPoint(breakpoint: Breakpoint): Thenable<[boolean, Breakpoint]> {
		return this.superior.addBreakPoint(breakpoint);
	}

	removeBreakPoint(breakpoint: Breakpoint): Thenable<boolean> {
		return this.superior.removeBreakPoint(breakpoint);
	}

	clearBreakPoints(source?: string): Thenable<any> {
		return this.superior.clearBreakPoints(source);
	}

	getThreads(): Thenable<Thread[]> {
		return this.superior.getThreads();
	}

	getStack(startFrame: number, maxLevels: number, thread: number): Thenable<Stack[]> {
		return this.superior.getStack(startFrame, maxLevels, thread);
	}

	getStackVariables(thread: number, frame: number): Thenable<Variable[]> {
		return this.superior.getStackVariables(thread, frame);
	}

	evalExpression(name: string, thread: number, frame: number): Thenable<any> {
		return this.superior.evalExpression(name, thread, frame);
	}

	isReady(): boolean {
		return this.superior.isReady();
	}

	changeVariable(name: string, rawValue: string): Thenable<any> {
		return this.superior.changeVariable(name, rawValue);
	}

	examineMemory(from: number, to: number): Thenable<any> {
		return this.superior.examineMemory(from, to);
	}

	private superior: MI2;

	contructor(superior: MI2) {
		this.superior = superior
	}
};