Sancaros/phantasmal-world
1
0
Fork 0
mirror of https://github.com/DaanVandenBosch/phantasmal-world.git synced 2025-04-04 22:58:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Removed the ability to step in a yielded thread.

Browse Source 
Changed the way the thread select widget works to make the thread status text update properly.
This commit is contained in:
jtuu 2020-05-01 23:02:29 +03:00
parent d8d0aa7ef6
commit b03a421ab5
4 changed files with 51 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
src/quest_editor/QuestRunner.ts
View File

@ -70,10 +70,8 @@ export class QuestRunner {
private readonly _breakpoints: WritableListProperty<Breakpoint> = list_property();
private readonly _pause_location: WritableProperty<number | undefined> = property(undefined);
private readonly _thread_ids: WritableListProperty<number> = list_property();
private readonly _debugging_thread_id: WritableProperty<number | undefined> = property(
undefined,
);
private readonly _active_thread_id: WritableProperty<number | undefined> = property(undefined);
private readonly _shown_thread_id: WritableProperty<number | undefined> = property(undefined);
private readonly debugger: Debugger;
@ -96,8 +94,8 @@ export class QuestRunner {
readonly breakpoints: ListProperty<Breakpoint> = this._breakpoints;
readonly pause_location: Property<number | undefined> = this._pause_location;
readonly thread_ids: ListProperty<number> = this._thread_ids;
readonly debugging_thread_id: Property<number | undefined> = this._debugging_thread_id;
readonly active_thread_id: Property<number | undefined> = this._active_thread_id;
readonly shown_thread_id: Property<number | undefined> = this._shown_thread_id;
get game_state(): GameState {
return this._game_state;
@ -171,8 +169,8 @@ export class QuestRunner {
this.debugger.deactivate_breakpoints();
this._state.val = QuestRunnerState.Stopped;
this._pause_location.val = undefined;
this._debugging_thread_id.val = undefined;
this._active_thread_id.val = undefined;
this._shown_thread_id.val = undefined;
this._thread_ids.clear();
this.npcs.splice(0, this.npcs.length);
this.objects.splice(0, this.objects.length);
@ -207,24 +205,18 @@ export class QuestRunner {
this._breakpoints.splice(0, Infinity, ...this.debugger.breakpoints);
}
set_debugging_thread(thread_id: number): void {
if (
thread_id !== this.debugging_thread_id.val &&
this.thread_ids.val.indexOf(thread_id) > -1
) {
// Update pause location.
const ip = this.vm.get_instruction_pointer(thread_id);
show_thread_location(thread_id: number): void {
// Update highlight location.
const ip = this.vm.get_instruction_pointer(thread_id);
// Exists in source?
if (ip && ip.source_location) {
this._debugging_thread_id.val = thread_id;
this.vm.set_debugging_thread(thread_id);
this._pause_location.val = ip.source_location.line_no;
} else {
this.logger.warn(
`Failed to select thread #${thread_id} because its execution location is unknown.`,
);
}
// Exists in source?
if (ip && ip.source_location) {
this._pause_location.val = ip.source_location.line_no;
this._shown_thread_id.val = thread_id;
} else {
this.logger.warn(
`Failed to select thread #${thread_id} because its execution location is unknown.`,
);
}
}
@ -295,8 +287,9 @@ export class QuestRunner {
};
private update_thread_info(): void {
this._debugging_thread_id.val = this.vm.get_debugging_thread_id();
this._active_thread_id.val = this.vm.get_current_thread_id();
const thread_id = this.vm.get_current_thread_id();
this._active_thread_id.val = thread_id;
this._shown_thread_id.val = thread_id;
this._thread_ids.splice(0, this._thread_ids.length.val, ...this.vm.get_thread_ids());
}

34
src/quest_editor/controllers/DebugController.ts
View File

@ -6,14 +6,19 @@ import { GuiStore, GuiTool } from "../../core/stores/GuiStore";
import { LogEntry } from "../../core/Logger";
import { LogStore } from "../stores/LogStore";
import { Severity } from "../../core/Severity";
import { map } from "../../core/observable";
type ThreadIdAndLabel = {
id: number;
label: string;
};
export class DebugController extends Controller {
readonly can_debug: Property<boolean>;
readonly can_step: Property<boolean>;
readonly can_stop: Property<boolean>;
readonly thread_ids: ListProperty<number>;
readonly debugging_thread_id: Property<number | undefined>;
readonly active_thread_id: Property<number | undefined>;
readonly threads: Property<ThreadIdAndLabel[]>;
readonly selected_thread_id: Property<ThreadIdAndLabel>;
readonly can_select_thread: Property<boolean>;
readonly log: ListProperty<LogEntry>;
readonly severity: Property<Severity>;
@ -31,11 +36,24 @@ export class DebugController extends Controller {
this.can_stop = quest_editor_store.quest_runner.running;
this.thread_ids = quest_editor_store.quest_runner.thread_ids;
this.threads = map(
(thread_ids, active_thread_id) =>
thread_ids.map(id => {
const status = active_thread_id === id ? "Active" : "Yielded";
return {
id,
label: `Thread #${id} (${status})`,
};
}),
quest_editor_store.quest_runner.thread_ids,
quest_editor_store.quest_runner.active_thread_id,
);
this.debugging_thread_id = quest_editor_store.quest_runner.debugging_thread_id;
this.active_thread_id = quest_editor_store.quest_runner.active_thread_id;
this.selected_thread_id = map(
(threads, shown_thread_id) => threads.find(thread => thread.id === shown_thread_id)!,
this.threads,
quest_editor_store.quest_runner.shown_thread_id,
);
this.can_select_thread = quest_editor_store.quest_runner.thread_ids.map(
ids => ids.length > 0 && quest_editor_store.quest_runner.running.val,
@ -92,6 +110,6 @@ export class DebugController extends Controller {
};
select_thread = (thread_id: number): void => {
this.quest_editor_store.quest_runner.set_debugging_thread(thread_id);
this.quest_editor_store.quest_runner.show_thread_location(thread_id);
};
}

12
src/quest_editor/gui/DebugView.ts
View File

@ -49,15 +49,12 @@ export class DebugView extends ResizableView {
icon_left: Icon.Stop,
tooltip: "Stop execution (Shift-F5)",
});
// TODO: ensure label is up-to-date.
const thread_select = new Select({
class: "quest_editor_DebugView_thread_select",
label: "Thread:",
items: ctrl.thread_ids,
to_label: id => {
const status = ctrl.active_thread_id.val === id ? "Active" : "Yielded";
return `Thread #${id} (${status})`;
},
items: ctrl.threads,
selected: ctrl.selected_thread_id,
to_label: id_and_label => id_and_label.label,
});
const severity_select = new Select({
class: "quest_editor_DebugView_severity_select",
@ -122,8 +119,7 @@ export class DebugView extends ResizableView {
stop_button.onclick.observe(ctrl.stop),
stop_button.enabled.bind_to(ctrl.can_stop),
thread_select.selected.observe(({ value }) => ctrl.select_thread(value!)),
thread_select.selected.bind_to(ctrl.debugging_thread_id),
thread_select.selected.observe(({ value }) => ctrl.select_thread(value!.id)),
thread_select.enabled.bind_to(ctrl.can_select_thread),
severity_select.selected.observe(

77
src/quest_editor/scripting/vm/VirtualMachine.ts
View File

@ -188,7 +188,6 @@ export class VirtualMachine {
private readonly breakpoints: InstructionPointer[] = [];
private paused = false;
private debugging_thread_id: number | undefined = undefined;
/**
* Set of unsupported opcodes that have already been logged. Each unsupported opcode will only
@ -206,7 +205,7 @@ export class VirtualMachine {
set step_mode(step_mode: StepMode) {
if (step_mode != undefined) {
const thread = this.threads.find(thread => thread.id === this.debugging_thread_id);
const thread = this.current_thread();
if (thread) {
thread.step_mode = step_mode;
@ -262,15 +261,9 @@ export class VirtualMachine {
);
}
const thread = new Thread(
this.io,
new InstructionPointer(seg_idx!, 0, this.object_code),
area_id,
this.threads.push(
new Thread(this.io, new InstructionPointer(seg_idx!, 0, this.object_code), area_id),
);
if (this.debugging_thread_id === undefined) {
this.debugging_thread_id = thread.id;
}
this.threads.push(thread);
}
/**
@ -296,19 +289,9 @@ export class VirtualMachine {
const thread = this.current_thread();
if (!thread) {
this.ignore_pauses_until_after_line = undefined;
return ExecutionResult.Suspended;
}
// This thread is the one currently selected for debugging?
const debugging_current_thread = thread.id === this.debugging_thread_id;
const allow_pausing = debugging_current_thread
? // Debugging current thread: Allow pausing if not ignoring pauses.
this.ignore_pauses_until_after_line === undefined
: // Not debugging current thread: Only allow pausing on breakpoints.
thread.step_mode === StepMode.BreakPoint;
// Get current instruction.
const frame = thread.current_stack_frame()!;
inst_ptr = frame.instruction_pointer;
@ -316,15 +299,11 @@ export class VirtualMachine {
// Check whether the VM needs to pause only if it's not already paused. In that case
// it's resuming.
if (allow_pausing && !this.paused) {
if (!this.paused) {
switch (thread.step_mode) {
case StepMode.BreakPoint:
if (this.breakpoints.findIndex(bp => bp.equals(inst_ptr!)) !== -1) {
this.paused = true;
// A breakpoint should interrupt the pause ignoring process
// since we are now in a different execution location.
this.debugging_thread_id = thread.id;
this.ignore_pauses_until_after_line = undefined;
return ExecutionResult.Paused;
}
break;
@ -360,15 +339,6 @@ export class VirtualMachine {
}
}
// Check if we can stop ignoring pauses.
if (debugging_current_thread && this.ignore_pauses_until_after_line !== undefined) {
const line = inst.asm?.mnemonic?.line_no;
// Reached line, allow pausing again.
if (this.ignore_pauses_until_after_line === line) {
this.ignore_pauses_until_after_line = undefined;
}
}
// Not paused, the next instruction can be executed.
this.paused = false;
@ -427,9 +397,7 @@ export class VirtualMachine {
this._halted = true;
this.paused = false;
this.breakpoints.splice(0, Infinity);
this.debugging_thread_id = undefined;
this.unsupported_opcodes_logged.clear();
this.ignore_pauses_until_after_line = undefined;
Thread.reset_id_counter();
}
}
@ -477,35 +445,6 @@ export class VirtualMachine {
}
}
set_debugging_thread(thread_id: number): void {
if (this.threads.find(thread => thread.id === thread_id)) {
this.debugging_thread_id = thread_id;
const ip = this.get_instruction_pointer(thread_id);
if (thread_id === this.current_thread()?.id) {
this.ignore_pauses_until_after_line = undefined;
}
// If switching away from the thread that is currently being executed
// it will look like we are paused but actually the VM has not yet
// processed the next instruction and is not yet actually paused.
// We shall ignore the next pause to prevent the user from having
// to press the step button twice.
else {
// Exists in source?
if (ip && ip.source_location) {
this.ignore_pauses_until_after_line = ip.source_location.line_no;
} else {
this.ignore_pauses_until_after_line = undefined;
}
}
}
}
get_debugging_thread_id(): number | undefined {
return this.debugging_thread_id;
}
get_thread_ids(): number[] {
return this.threads.map(thread => thread.id);
}
@ -523,14 +462,6 @@ export class VirtualMachine {
this.threads.splice(thread_idx, 1);
if (thread.id === this.debugging_thread_id) {
if (this.threads.length === 0) {
this.debugging_thread_id = undefined;
} else {
this.debugging_thread_id = this.threads[0].id;
}
}
if (this.thread_idx >= thread_idx && this.thread_idx > 0) {
this.thread_idx--;
}