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

Split VM code into separate files.

Browse Source
This commit is contained in:
jtuu 2019-10-15 15:34:30 +03:00
parent 9facc6357c
commit f8dc1af8ea
3 changed files with 305 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

298
src/quest_editor/scripting/vm/index.ts
View File

@ -79,8 +79,16 @@ import {
OP_WINEND, OP_WINEND,
} from "../opcodes"; } from "../opcodes";
import Logger from "js-logger"; import Logger from "js-logger";
import { ArrayBufferCursor } from "../../../core/data_formats/cursor/ArrayBufferCursor"; import { VirtualMachineMemoryBuffer, VirtualMachineMemory } from "./memory";
import { Endianness } from "../../../core/data_formats/Endianness"; import {
ComparisonOperation,
numeric_ops,
comparison_ops,
rest,
BinaryNumericOperation,
andsecond,
andreduce,
} from "./utils";
const logger = Logger.get("quest_editor/scripting/vm"); const logger = Logger.get("quest_editor/scripting/vm");
@ -99,292 +107,6 @@ export enum ExecutionResult {
Halted, Halted,
} }
type BinaryNumericOperation = (a: number, b: number) => number;
const numeric_ops: Record<
"add" | "sub" | "mul" | "div" | "idiv" | "mod" | "and" | "or" | "xor" | "shl" | "shr",
BinaryNumericOperation
> = {
add: (a, b) => a + b,
sub: (a, b) => a - b,
mul: (a, b) => a * b,
div: (a, b) => a / b,
idiv: (a, b) => Math.floor(a / b),
mod: (a, b) => a % b,
and: (a, b) => a & b,
or: (a, b) => a | b,
xor: (a, b) => a ^ b,
shl: (a, b) => a << b,
shr: (a, b) => a >>> b,
};
type ComparisonOperation = (a: number, b: number) => boolean;
const comparison_ops: Record<"eq" | "neq" | "gt" | "lt" | "gte" | "lte", ComparisonOperation> = {
eq: (a, b) => a === b,
neq: (a, b) => a !== b,
gt: (a, b) => a > b,
lt: (a, b) => a < b,
gte: (a, b) => a >= b,
lte: (a, b) => a <= b,
};
/**
* Short-circuiting fold.
*/
function andfold<T, A>(fn: (acc: A, cur: T) => A | undefined, init: A, lst: T[]): A | undefined {
let acc = init;
for (const item of lst) {
const new_val = fn(acc, item);
if (new_val === undefined) {
return undefined;
} else {
acc = new_val;
}
}
return acc;
}
/**
* Short-circuiting reduce.
*/
function andreduce<T>(fn: (acc: T, cur: T) => T | undefined, lst: T[]): T | undefined {
return andfold(fn, lst[0], lst.slice(1));
}
/**
* Applies the given arguments to the given function.
* Returns the second argument if the function returns a truthy value, else undefined.
*/
function andsecond<T>(fn: (first: T, second: T) => any, first: T, second: T): T | undefined {
if (fn(first, second)) {
return second;
}
return undefined;
}
function rest<T>(lst: T[]): T[] {
return lst.slice(1);
}
type Range = [number, number];
function ranges_overlap(a: Range, b: Range): boolean {
return a[0] <= b[1] && b[0] <= a[1];
}
class VirtualMachineMemoryBuffer extends ArrayBufferCursor {
/**
* The memory this buffer belongs to.
*/
public readonly memory: VirtualMachineMemory;
/**
* The memory address of this buffer.
*/
public readonly address: number;
constructor(memory: VirtualMachineMemory, address: number, size: number) {
super(new ArrayBuffer(size), Endianness.Little);
this.memory = memory;
this.address = address;
}
public get_offset(byte_offset: number): VirtualMachineMemorySlot | undefined {
return this.memory.get(this.address + byte_offset);
}
public free(): void {
this.memory.free(this.address);
}
public zero(): void {
new Uint32Array(this.backing_buffer).fill(0);
}
}
/**
* Represents a single location in memory.
*/
class VirtualMachineMemorySlot {
/**
* The memory this slot belongs to.
*/
public readonly memory: VirtualMachineMemory;
/**
* The memory address this slots represents.
*/
public readonly address: number;
/**
* The allocated buffer this slot is a part of.
*/
public readonly buffer: VirtualMachineMemoryBuffer;
/**
* The offset that this slot represents in the buffer.
*/
public readonly byte_offset: number;
constructor(
memory: VirtualMachineMemory,
address: number,
buffer: VirtualMachineMemoryBuffer,
byte_offset: number,
) {
this.memory = memory;
this.address = address;
this.buffer = buffer;
this.byte_offset = byte_offset;
}
}
/**
* Maps memory addresses to buffers.
*/
class VirtualMachineMemory {
private allocated_ranges: Range[] = [];
private ranges_sorted: boolean = true;
private memory: Map<number, VirtualMachineMemorySlot> = new Map();
private sort_ranges(): void {
this.allocated_ranges.sort((a, b) => a[0] - b[0]);
this.ranges_sorted = true;
}
/**
* Would a buffer of the given size fit at the given address?
*/
private will_fit(address: number, size: number): boolean {
const fit_range: Range = [address, address + size - 1];
if (!this.ranges_sorted) {
this.sort_ranges();
}
// check if it would overlap any already allocated space
for (const alloc_range of this.allocated_ranges) {
if (ranges_overlap(alloc_range, fit_range)) {
return false;
}
}
return true;
}
/**
* Returns an address where a buffer of the given size would fit.
*/
private find_free_space(size: number): number {
let address = 0;
// nothing yet allocated, we can place it wherever
if (this.allocated_ranges.length < 1) {
return address;
}
if (!this.ranges_sorted) {
this.sort_ranges();
}
// check if buffer could fit in between allocated buffers
for (const alloc_range of this.allocated_ranges) {
if (!ranges_overlap(alloc_range, [address, address + size - 1])) {
return address;
}
address = alloc_range[1] + 1;
}
// just place it at the end
return address;
}
/**
* Allocate a buffer of the given size at the given address.
* If the address is omitted a suitable location is chosen.
* @returns The allocated buffer.
*/
public allocate(size: number, address?: number): VirtualMachineMemoryBuffer {
if (size <= 0) {
throw new Error("Allocation failed: The size of the buffer must be greater than 0");
}
// check if given address is good or find an address if none was given
if (address === undefined) {
address = this.find_free_space(size);
} else {
if (!this.will_fit(address, size)) {
throw new Error(
"Allocation failed: Cannot fit a buffer of the given size at the given address",
);
}
}
// save the range of allocated memory
this.allocated_ranges.push([address, address + size - 1]);
this.ranges_sorted = false;
// the actual buffer
const buf = new VirtualMachineMemoryBuffer(this, address, size);
// set addresses to correct buffer offsets
for (let offset = 0; offset < size; offset++) {
this.memory.set(
address + offset,
new VirtualMachineMemorySlot(this, address, buf, offset),
);
}
return buf;
}
/**
* Free the memory allocated for the buffer at the given address.
*/
public free(address: number): void {
// check if address is a valid allocated buffer
let range: Range | undefined = undefined;
let range_idx = -1;
for (let i = 0; i < this.allocated_ranges.length; i++) {
const cur = this.allocated_ranges[i];
if (cur[0] === address) {
range = cur;
range_idx = i;
break;
}
}
if (range === undefined) {
throw new Error("Free failed: Given address is not the start of an allocated buffer");
}
const [alloc_start, alloc_end] = range;
// remove addresses
for (let addr = alloc_start; addr <= alloc_end; addr++) {
this.memory.delete(addr);
}
// remove range
this.allocated_ranges.splice(range_idx, 1);
}
/**
* Gets the memory at the given address. Returns undefined if
* there is nothing allocated at the given address.
*/
public get(address: number): VirtualMachineMemorySlot | undefined {
if (this.memory.has(address)) {
return this.memory.get(address)!;
}
return undefined;
}
}
export class VirtualMachine { export class VirtualMachine {
private memory = new VirtualMachineMemory(); private memory = new VirtualMachineMemory();
private registers = this.memory.allocate( private registers = this.memory.allocate(

212
src/quest_editor/scripting/vm/memory.ts Normal file
View File

@ -0,0 +1,212 @@
import { ArrayBufferCursor } from "../../../core/data_formats/cursor/ArrayBufferCursor";
import { Endianness } from "../../../core/data_formats/Endianness";
import { Range, ranges_overlap } from "./utils";
export class VirtualMachineMemoryBuffer extends ArrayBufferCursor {
/**
* The memory this buffer belongs to.
*/
public readonly memory: VirtualMachineMemory;
/**
* The memory address of this buffer.
*/
public readonly address: number;
constructor(memory: VirtualMachineMemory, address: number, size: number) {
super(new ArrayBuffer(size), Endianness.Little);
this.memory = memory;
this.address = address;
}
public get_offset(byte_offset: number): VirtualMachineMemorySlot | undefined {
return this.memory.get(this.address + byte_offset);
}
public free(): void {
this.memory.free(this.address);
}
public zero(): void {
new Uint32Array(this.backing_buffer).fill(0);
}
}
/**
* Represents a single location in memory.
*/
export class VirtualMachineMemorySlot {
/**
* The memory this slot belongs to.
*/
public readonly memory: VirtualMachineMemory;
/**
* The memory address this slots represents.
*/
public readonly address: number;
/**
* The allocated buffer this slot is a part of.
*/
public readonly buffer: VirtualMachineMemoryBuffer;
/**
* The offset that this slot represents in the buffer.
*/
public readonly byte_offset: number;
constructor(
memory: VirtualMachineMemory,
address: number,
buffer: VirtualMachineMemoryBuffer,
byte_offset: number,
) {
this.memory = memory;
this.address = address;
this.buffer = buffer;
this.byte_offset = byte_offset;
}
}
/**
* Maps memory addresses to buffers.
*/
export class VirtualMachineMemory {
private allocated_ranges: Range[] = [];
private ranges_sorted: boolean = true;
private memory: Map<number, VirtualMachineMemorySlot> = new Map();
private sort_ranges(): void {
this.allocated_ranges.sort((a, b) => a[0] - b[0]);
this.ranges_sorted = true;
}
/**
* Would a buffer of the given size fit at the given address?
*/
private will_fit(address: number, size: number): boolean {
const fit_range: Range = [address, address + size - 1];
if (!this.ranges_sorted) {
this.sort_ranges();
}
// check if it would overlap any already allocated space
for (const alloc_range of this.allocated_ranges) {
if (ranges_overlap(alloc_range, fit_range)) {
return false;
}
}
return true;
}
/**
* Returns an address where a buffer of the given size would fit.
*/
private find_free_space(size: number): number {
let address = 0;
// nothing yet allocated, we can place it wherever
if (this.allocated_ranges.length < 1) {
return address;
}
if (!this.ranges_sorted) {
this.sort_ranges();
}
// check if buffer could fit in between allocated buffers
for (const alloc_range of this.allocated_ranges) {
if (!ranges_overlap(alloc_range, [address, address + size - 1])) {
return address;
}
address = alloc_range[1] + 1;
}
// just place it at the end
return address;
}
/**
* Allocate a buffer of the given size at the given address.
* If the address is omitted a suitable location is chosen.
* @returns The allocated buffer.
*/
public allocate(size: number, address?: number): VirtualMachineMemoryBuffer {
if (size <= 0) {
throw new Error("Allocation failed: The size of the buffer must be greater than 0");
}
// check if given address is good or find an address if none was given
if (address === undefined) {
address = this.find_free_space(size);
} else {
if (!this.will_fit(address, size)) {
throw new Error(
"Allocation failed: Cannot fit a buffer of the given size at the given address",
);
}
}
// save the range of allocated memory
this.allocated_ranges.push([address, address + size - 1]);
this.ranges_sorted = false;
// the actual buffer
const buf = new VirtualMachineMemoryBuffer(this, address, size);
// set addresses to correct buffer offsets
for (let offset = 0; offset < size; offset++) {
this.memory.set(
address + offset,
new VirtualMachineMemorySlot(this, address, buf, offset),
);
}
return buf;
}
/**
* Free the memory allocated for the buffer at the given address.
*/
public free(address: number): void {
// check if address is a valid allocated buffer
let range: Range | undefined = undefined;
let range_idx = -1;
for (let i = 0; i < this.allocated_ranges.length; i++) {
const cur = this.allocated_ranges[i];
if (cur[0] === address) {
range = cur;
range_idx = i;
break;
}
}
if (range === undefined) {
throw new Error("Free failed: Given address is not the start of an allocated buffer");
}
const [alloc_start, alloc_end] = range;
// remove addresses
for (let addr = alloc_start; addr <= alloc_end; addr++) {
this.memory.delete(addr);
}
// remove range
this.allocated_ranges.splice(range_idx, 1);
}
/**
* Gets the memory at the given address. Returns undefined if
* there is nothing allocated at the given address.
*/
public get(address: number): VirtualMachineMemorySlot | undefined {
if (this.memory.has(address)) {
return this.memory.get(address)!;
}
return undefined;
}
}

83
src/quest_editor/scripting/vm/utils.ts Normal file
View File

@ -0,0 +1,83 @@
export type BinaryNumericOperation = (a: number, b: number) => number;
export const numeric_ops: Record<
"add" | "sub" | "mul" | "div" | "idiv" | "mod" | "and" | "or" | "xor" | "shl" | "shr",
BinaryNumericOperation
> = {
add: (a, b) => a + b,
sub: (a, b) => a - b,
mul: (a, b) => a * b,
div: (a, b) => a / b,
idiv: (a, b) => Math.floor(a / b),
mod: (a, b) => a % b,
and: (a, b) => a & b,
or: (a, b) => a | b,
xor: (a, b) => a ^ b,
shl: (a, b) => a << b,
shr: (a, b) => a >>> b,
};
export type ComparisonOperation = (a: number, b: number) => boolean;
export const comparison_ops: Record<
"eq" | "neq" | "gt" | "lt" | "gte" | "lte",
ComparisonOperation
> = {
eq: (a, b) => a === b,
neq: (a, b) => a !== b,
gt: (a, b) => a > b,
lt: (a, b) => a < b,
gte: (a, b) => a >= b,
lte: (a, b) => a <= b,
};
/**
* Short-circuiting fold.
*/
export function andfold<T, A>(
fn: (acc: A, cur: T) => A | undefined,
init: A,
lst: T[],
): A | undefined {
let acc = init;
for (const item of lst) {
const new_val = fn(acc, item);
if (new_val === undefined) {
return undefined;
} else {
acc = new_val;
}
}
return acc;
}
/**
* Short-circuiting reduce.
*/
export function andreduce<T>(fn: (acc: T, cur: T) => T | undefined, lst: T[]): T | undefined {
return andfold(fn, lst[0], lst.slice(1));
}
/**
* Applies the given arguments to the given function.
* Returns the second argument if the function returns a truthy value, else undefined.
*/
export function andsecond<T>(fn: (first: T, second: T) => any, first: T, second: T): T | undefined {
if (fn(first, second)) {
return second;
}
return undefined;
}
export function rest<T>(lst: T[]): T[] {
return lst.slice(1);
}
export type Range = [number, number];
export function ranges_overlap(a: Range, b: Range): boolean {
return a[0] <= b[1] && b[0] <= a[1];
}