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

Object code and labels are now represented by segments. Each segment describes the instructions or data denoted by a label.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2019-07-29 01:02:22 +02:00
parent f95e7ea220
commit 3edb861693
17 changed files with 879 additions and 728 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/data_formats/cursor/AbstractCursor.ts
View File

@ -168,6 +168,19 @@ export abstract class AbstractCursor implements Cursor {
return array; return array;
} }
i32_array(n: number): number[] {
this.check_size("n", n, 4 * n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.dv.getInt32(this.offset + this.position, this.little_endian));
this._position += 4;
}
return array;
}
vec2_f32(): Vec2 { vec2_f32(): Vec2 {
return new Vec2(this.f32(), this.f32()); return new Vec2(this.f32(), this.f32());
} }

5
src/data_formats/cursor/Cursor.ts
View File

@ -128,6 +128,11 @@ export interface Cursor {
*/ */
u32_array(n: number): number[]; u32_array(n: number): number[];
/**
* Reads n signed 32-bit integers and increments position by 4n.
*/
i32_array(n: number): number[];
/** /**
* Reads 2 32-bit floating point numbers and increments position by 8. * Reads 2 32-bit floating point numbers and increments position by 8.
*/ */

14
src/data_formats/parsing/quest/bin.test.ts
View File

@ -1,15 +1,15 @@
import { readFileSync } from "fs"; import { readFileSync } from "fs";
import { Endianness } from "../.."; import { Endianness } from "../..";
import { prs_decompress } from "../../compression/prs/decompress";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor"; import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { BufferCursor } from "../../cursor/BufferCursor"; import { BufferCursor } from "../../cursor/BufferCursor";
import { parse_bin, write_bin } from "./bin"; import { parse_bin, write_bin } from "./bin";
import { prs_decompress } from "../../compression/prs/decompress";
/** /**
* Parse a file, convert the resulting structure to BIN again and check whether the end result is equal to the original. * Parse a file, convert the resulting structure to BIN again and check whether the end result is equal to the original.
*/ */
test("parse_bin and write_bin", () => { function test_quest(path: string) {
const orig_buffer = readFileSync("test/resources/quest118_e.bin"); const orig_buffer = readFileSync(path);
const orig_bin = prs_decompress(new BufferCursor(orig_buffer, Endianness.Little)); const orig_bin = prs_decompress(new BufferCursor(orig_buffer, Endianness.Little));
const test_buffer = write_bin(parse_bin(orig_bin)); const test_buffer = write_bin(parse_bin(orig_bin));
const test_bin = new ArrayBufferCursor(test_buffer, Endianness.Little); const test_bin = new ArrayBufferCursor(test_buffer, Endianness.Little);
@ -33,4 +33,12 @@ test("parse_bin and write_bin", () => {
} }
expect(matching_bytes).toBe(orig_bin.size); expect(matching_bytes).toBe(orig_bin.size);
}
test("parse_bin and write_bin with quest118_e.bin", () => {
test_quest("test/resources/quest118_e.bin");
});
test("parse_bin and write_bin with quest27_e.bin", () => {
test_quest("test/resources/quest27_e.bin");
}); });

321
src/data_formats/parsing/quest/bin.ts
View File

@ -1,10 +1,12 @@
import Logger from "js-logger"; import Logger from "js-logger";
import { Endianness } from "../.."; import { Endianness } from "../..";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { Cursor } from "../../cursor/Cursor"; import { Cursor } from "../../cursor/Cursor";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor"; import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
import { WritableCursor } from "../../cursor/WritableCursor"; import { WritableCursor } from "../../cursor/WritableCursor";
import { ResizableBuffer } from "../../ResizableBuffer"; import { ResizableBuffer } from "../../ResizableBuffer";
import { Opcode, OPCODES, Type } from "./opcodes"; import { Opcode, OPCODES, Type } from "./opcodes";
import { number } from "prop-types";
export * from "./opcodes"; export * from "./opcodes";
@ -17,32 +19,9 @@ export class BinFile {
readonly quest_name: string, readonly quest_name: string,
readonly short_description: string, readonly short_description: string,
readonly long_description: string, readonly long_description: string,
/** readonly object_code: Segment[],
* Map of labels to instruction indices.
*/
readonly labels: Map<number, number>,
readonly instructions: Instruction[],
readonly shop_items: number[] readonly shop_items: number[]
) {} ) {}
get_label_instructions(label: number): Instruction[] | undefined {
const index = this.labels.get(label);
if (index == null || index > this.instructions.length) return undefined;
const instructions: Instruction[] = [];
for (let i = index; i < this.instructions.length; i++) {
const instruction = this.instructions[i];
instructions.push(instruction);
if (instruction.opcode === Opcode.ret) {
break;
}
}
return instructions;
}
} }
/** /**
@ -68,13 +47,13 @@ export class Instruction {
const arg = args[i]; const arg = args[i];
this.param_to_args[i] = []; this.param_to_args[i] = [];
if (arg == null) { if (arg == undefined) {
break; break;
} }
switch (type) { switch (type) {
case Type.U8Var: case Type.U8Var:
case Type.U16Var: case Type.ILabelVar:
this.arg_size++; this.arg_size++;
for (let j = i; j < args.length; j++) { for (let j = i; j < args.length; j++) {
@ -90,10 +69,32 @@ export class Instruction {
} }
} }
this.size = opcode.code_size + this.arg_size; this.size = opcode.size + this.arg_size;
} }
} }
export enum SegmentType {
Instructions,
Data,
}
/**
* Segment of object code.
*/
export type Segment = InstructionSegment | DataSegment;
export type InstructionSegment = {
type: SegmentType.Instructions;
label: number;
instructions: Instruction[];
};
export type DataSegment = {
type: SegmentType.Data;
label: number;
data: ArrayBuffer;
};
/** /**
* Instruction argument. * Instruction argument.
*/ */
@ -121,56 +122,69 @@ export function parse_bin(cursor: Cursor, lenient: boolean = false): BinFile {
const shop_items = cursor.u32_array(932); const shop_items = cursor.u32_array(932);
const label_offset_count = Math.floor((cursor.size - label_offset_table_offset) / 4);
cursor.seek_start(label_offset_table_offset);
const label_offsets = cursor.i32_array(label_offset_count);
const offset_to_labels = new Map<number, number[]>();
for (let label = 0; label < label_offsets.length; label++) {
const offset = label_offsets[label];
if (offset !== -1) {
let labels = offset_to_labels.get(offset);
if (!labels) {
labels = [];
offset_to_labels.set(offset, labels);
}
labels.push(label);
}
}
const object_code = cursor const object_code = cursor
.seek_start(object_code_offset) .seek_start(object_code_offset)
.take(label_offset_table_offset - object_code_offset); .take(label_offset_table_offset - object_code_offset);
const instructions = parse_object_code(object_code, lenient); const segments = parse_object_code(object_code, offset_to_labels, lenient);
let instruction_size = 0; // Sanity check parsed object code.
let segments_size = 0;
for (const instruction of instructions) { for (const segment of segments) {
instruction_size += instruction.size; if (segment.type === SegmentType.Instructions) {
for (const instruction of segment.instructions) {
segments_size += instruction.size;
} }
if (object_code.size !== instruction_size) {
throw new Error(
`Expected to parse ${object_code.size} bytes but parsed ${instruction_size} instead.`
);
}
const label_offset_count = Math.floor((cursor.size - label_offset_table_offset) / 4);
cursor.seek_start(label_offset_table_offset);
const labels = new Map<number, number>();
for (let label = 0; label < label_offset_count; ++label) {
const offset = cursor.i32();
if (offset >= 0) {
let size = 0;
let index = 0;
for (const instruction of instructions) {
if (offset === size) {
break;
} else if (offset < size) {
logger.warn(
`Label ${label} offset ${offset} does not point to the start of an instruction.`
);
break;
}
size += instruction.size;
index++;
}
if (index >= instructions.length) {
logger.warn(`Label ${label} offset ${offset} is too large.`);
} else { } else {
labels.set(label, index); segments_size += segment.data.byteLength;
} }
} }
if (object_code.size !== segments_size) {
const message = `Expected to parse ${object_code.size} bytes but parsed ${segments_size} instead.`;
if (lenient) {
logger.error(message);
} else {
throw new Error(message);
}
}
// Verify labels.
outer: for (let label = 0; label < label_offset_count; label++) {
if (label_offsets[label] !== -1) {
for (const segment of segments) {
if (segment.label === label) {
continue outer;
}
}
logger.warn(
`Label ${label} with offset ${label_offsets[label]} does not point to anything.`
);
}
} }
return new BinFile( return new BinFile(
@ -179,22 +193,14 @@ export function parse_bin(cursor: Cursor, lenient: boolean = false): BinFile {
quest_name, quest_name,
short_description, short_description,
long_description, long_description,
labels, segments,
instructions,
shop_items shop_items
); );
} }
export function write_bin(bin: BinFile): ArrayBuffer { export function write_bin(bin: BinFile): ArrayBuffer {
const labels: number[] = [...bin.labels.entries()].reduce((ls, [l, i]) => {
ls[l] = i;
return ls;
}, new Array<number>());
const object_code_offset = 4652; const object_code_offset = 4652;
const buffer = new ResizableBuffer( const buffer = new ResizableBuffer(object_code_offset + 100 * bin.object_code.length);
object_code_offset + 10 * bin.instructions.length + 4 * labels.length
);
const cursor = new ResizableBufferCursor(buffer, Endianness.Little); const cursor = new ResizableBufferCursor(buffer, Endianness.Little);
cursor.write_u32(object_code_offset); cursor.write_u32(object_code_offset);
@ -222,26 +228,14 @@ export function write_bin(bin: BinFile): ArrayBuffer {
cursor.write_u8(0); cursor.write_u8(0);
} }
const object_code_size = write_object_code(cursor, bin.instructions); const { size: object_code_size, label_offsets } = write_object_code(cursor, bin.object_code);
for (let label = 0; label < labels.length; label++) { for (let label = 0; label < label_offsets.length; label++) {
const index = labels[label]; const offset = label_offsets[label];
if (index == null) { if (offset == undefined) {
cursor.write_i32(-1); cursor.write_i32(-1);
} else { } else {
let offset = 0;
for (let j = 0; j < bin.instructions.length; j++) {
const instruction = bin.instructions[j];
if (j === index) {
break;
} else {
offset += instruction.size;
}
}
cursor.write_i32(offset); cursor.write_i32(offset);
} }
} }
@ -255,11 +249,83 @@ export function write_bin(bin: BinFile): ArrayBuffer {
return cursor.seek_start(0).array_buffer(file_size); return cursor.seek_start(0).array_buffer(file_size);
} }
function parse_object_code(cursor: Cursor, lenient: boolean): Instruction[] { function parse_object_code(
const instructions: Instruction[] = []; cursor: Cursor,
offset_to_labels: Map<number, number[]>,
lenient: boolean
): Segment[] {
const segments: Segment[] = [];
const data_labels = new Set<number>();
try { try {
let instructions: Instruction[] | undefined;
while (cursor.bytes_left) { while (cursor.bytes_left) {
// See if this instruction and the ones following belong to a new label.
const offset = cursor.position;
const labels: number[] | undefined = offset_to_labels.get(offset);
// Check whether we've encountered a data segment.
// If a single label that points to this segment is referred to from a data context we assume the segment is a data segment.
if (labels && labels.some(label => data_labels.has(label))) {
for (const [label_offset, labels] of offset_to_labels.entries()) {
if (label_offset > offset) {
// We create empty segments for all but the last label.
// The data will be in the last label's segment.
for (let i = 0; i < labels.length - 1; i++) {
segments.push({
type: SegmentType.Data,
label: labels[i],
data: new ArrayBuffer(0),
});
}
segments.push({
type: SegmentType.Data,
label: labels[labels.length - 1],
data: cursor.array_buffer(label_offset - offset),
});
break;
}
}
instructions = undefined;
continue;
}
// Parse as instruction.
if (labels == undefined) {
if (instructions == undefined) {
logger.warn(`Unlabelled instructions at ${offset}.`);
instructions = [];
segments.push({
type: SegmentType.Instructions,
label: -1,
instructions,
});
}
} else {
for (let i = 0; i < labels.length - 1; i++) {
segments.push({
type: SegmentType.Instructions,
label: labels[i],
instructions: [],
});
}
instructions = [];
segments.push({
type: SegmentType.Instructions,
label: labels[labels.length - 1],
instructions,
});
}
// Parse the opcode.
const main_opcode = cursor.u8(); const main_opcode = cursor.u8();
let opcode_index; let opcode_index;
@ -275,15 +341,30 @@ function parse_object_code(cursor: Cursor, lenient: boolean): Instruction[] {
let opcode = OPCODES[opcode_index]; let opcode = OPCODES[opcode_index];
// Parse the arguments.
try { try {
const args = parse_instruction_arguments(cursor, opcode); const args = parse_instruction_arguments(cursor, opcode);
instructions.push(new Instruction(opcode, args)); instructions.push(new Instruction(opcode, args));
// Check whether we can deduce a data segment label.
for (let i = 0; i < opcode.params.length; i++) {
const param_type = opcode.params[i].type;
const arg_value = args[i].value;
if (param_type === Type.DLabel) {
data_labels.add(arg_value);
}
}
} catch (e) { } catch (e) {
logger.warn( if (lenient) {
logger.error(
`Exception occurred while parsing arguments for instruction ${opcode.mnemonic}.`, `Exception occurred while parsing arguments for instruction ${opcode.mnemonic}.`,
e e
); );
instructions.push(new Instruction(opcode, [])); instructions.push(new Instruction(opcode, []));
} else {
throw e;
}
} }
} }
} catch (e) { } catch (e) {
@ -294,7 +375,7 @@ function parse_object_code(cursor: Cursor, lenient: boolean): Instruction[] {
} }
} }
return instructions; return segments;
} }
function parse_instruction_arguments(cursor: Cursor, opcode: Opcode): Arg[] { function parse_instruction_arguments(cursor: Cursor, opcode: Opcode): Arg[] {
@ -320,13 +401,19 @@ function parse_instruction_arguments(cursor: Cursor, opcode: Opcode): Arg[] {
case Type.Register: case Type.Register:
args.push({ value: cursor.u8(), size: 1 }); args.push({ value: cursor.u8(), size: 1 });
break; break;
case Type.ILabel:
args.push({ value: cursor.u16(), size: 2 });
break;
case Type.DLabel:
args.push({ value: cursor.u16(), size: 2 });
break;
case Type.U8Var: case Type.U8Var:
{ {
const arg_size = cursor.u8(); const arg_size = cursor.u8();
args.push(...cursor.u8_array(arg_size).map(value => ({ value, size: 1 }))); args.push(...cursor.u8_array(arg_size).map(value => ({ value, size: 1 })));
} }
break; break;
case Type.U16Var: case Type.ILabelVar:
{ {
const arg_size = cursor.u8(); const arg_size = cursor.u8();
args.push(...cursor.u16_array(arg_size).map(value => ({ value, size: 2 }))); args.push(...cursor.u16_array(arg_size).map(value => ({ value, size: 2 })));
@ -351,13 +438,25 @@ function parse_instruction_arguments(cursor: Cursor, opcode: Opcode): Arg[] {
return args; return args;
} }
function write_object_code(cursor: WritableCursor, instructions: Instruction[]): number { function write_object_code(
cursor: WritableCursor,
segments: Segment[]
): { size: number; label_offsets: number[] } {
const start_pos = cursor.position; const start_pos = cursor.position;
// Keep track of label offsets.
const label_offsets: number[] = [];
for (const instruction of instructions) { // Write instructions first.
for (const segment of segments) {
if (segment.label !== -1) {
label_offsets[segment.label] = cursor.position - start_pos;
}
if (segment.type === SegmentType.Instructions) {
for (const instruction of segment.instructions) {
const opcode = instruction.opcode; const opcode = instruction.opcode;
if (opcode.code_size === 2) { if (opcode.size === 2) {
cursor.write_u8(opcode.code >>> 8); cursor.write_u8(opcode.code >>> 8);
} }
@ -387,11 +486,17 @@ function write_object_code(cursor: WritableCursor, instructions: Instruction[]):
case Type.Register: case Type.Register:
cursor.write_u8(arg.value); cursor.write_u8(arg.value);
break; break;
case Type.ILabel:
cursor.write_u16(arg.value);
break;
case Type.DLabel:
cursor.write_u16(arg.value);
break;
case Type.U8Var: case Type.U8Var:
cursor.write_u8(args.length); cursor.write_u8(args.length);
cursor.write_u8_array(args.map(arg => arg.value)); cursor.write_u8_array(args.map(arg => arg.value));
break; break;
case Type.U16Var: case Type.ILabelVar:
cursor.write_u8(args.length); cursor.write_u8(args.length);
cursor.write_u16_array(args.map(arg => arg.value)); cursor.write_u16_array(args.map(arg => arg.value));
break; break;
@ -400,11 +505,17 @@ function write_object_code(cursor: WritableCursor, instructions: Instruction[]):
break; break;
default: default:
throw new Error( throw new Error(
`Parameter type ${Type[param.type]} (${param.type}) not implemented.` `Parameter type ${Type[param.type]} (${
param.type
}) not implemented.`
); );
} }
} }
} }
} else {
return cursor.position - start_pos; cursor.write_cursor(new ArrayBufferCursor(segment.data, cursor.endianness));
}
}
return { size: cursor.position - start_pos, label_offsets };
} }

8
src/data_formats/parsing/quest/index.test.ts
View File

@ -90,8 +90,12 @@ function roundtrip_test(path: string, file_name: string, contents: Buffer): void
expect(test_area_variant.id).toBe(orig_area_variant.id); expect(test_area_variant.id).toBe(orig_area_variant.id);
} }
expect(test_quest.instructions.length).toBe(orig_quest.instructions.length); expect(test_quest.object_code.length).toBe(orig_quest.object_code.length);
expect(test_quest.labels.size).toBe(orig_quest.labels.size);
for (let i = 0; i < orig_quest.object_code.length; i++) {
expect(test_quest.object_code[i].type).toBe(orig_quest.object_code[i].type);
expect(test_quest.object_code[i].label).toBe(orig_quest.object_code[i].label);
}
}); });
} }

57
src/data_formats/parsing/quest/index.ts
View File

@ -1,6 +1,14 @@
import Logger from "js-logger"; import Logger from "js-logger";
import { Endianness } from "../.."; import { Endianness } from "../..";
import { AreaVariant, NpcType, ObjectType, Quest, QuestNpc, QuestObject } from "../../../domain"; import {
AreaVariant,
Episode,
NpcType,
ObjectType,
Quest,
QuestNpc,
QuestObject,
} from "../../../domain";
import { area_store } from "../../../stores/AreaStore"; import { area_store } from "../../../stores/AreaStore";
import { prs_compress } from "../../compression/prs/compress"; import { prs_compress } from "../../compression/prs/compress";
import { prs_decompress } from "../../compression/prs/decompress"; import { prs_decompress } from "../../compression/prs/decompress";
@ -8,17 +16,17 @@ import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { Cursor } from "../../cursor/Cursor"; import { Cursor } from "../../cursor/Cursor";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor"; import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
import { Vec3 } from "../../vector"; import { Vec3 } from "../../vector";
import { BinFile, Instruction, parse_bin, write_bin } from "./bin"; import { BinFile, Instruction, InstructionSegment, parse_bin, SegmentType, write_bin } from "./bin";
import { DatFile, DatNpc, DatObject, parse_dat, write_dat } from "./dat"; import { DatFile, DatNpc, DatObject, parse_dat, write_dat } from "./dat";
import { parse_qst, QstContainedFile, write_qst } from "./qst";
import { Opcode } from "./opcodes"; import { Opcode } from "./opcodes";
import { parse_qst, QstContainedFile, write_qst } from "./qst";
const logger = Logger.get("data_formats/parsing/quest"); const logger = Logger.get("data_formats/parsing/quest");
/** /**
* High level parsing function that delegates to lower level parsing functions. * High level parsing function that delegates to lower level parsing functions.
* *
* Always delegates to parseQst at the moment. * Always delegates to parse_qst at the moment.
*/ */
export function parse_quest(cursor: Cursor, lenient: boolean = false): Quest | undefined { export function parse_quest(cursor: Cursor, lenient: boolean = false): Quest | undefined {
const qst = parse_qst(cursor); const qst = parse_qst(cursor);
@ -40,8 +48,6 @@ export function parse_quest(cursor: Cursor, lenient: boolean = false): Quest | u
} }
} }
// TODO: deal with missing/multiple DAT or BIN file.
if (!dat_file) { if (!dat_file) {
logger.error("File contains no DAT file."); logger.error("File contains no DAT file.");
return; return;
@ -63,21 +69,24 @@ export function parse_quest(cursor: Cursor, lenient: boolean = false): Quest | u
let episode = 1; let episode = 1;
let area_variants: AreaVariant[] = []; let area_variants: AreaVariant[] = [];
if (bin.labels.size) { if (bin.object_code.length) {
if (bin.labels.has(0)) { let label_0_segment: InstructionSegment | undefined;
const label_0_instructions = bin.get_label_instructions(0);
if (label_0_instructions) { for (const segment of bin.object_code) {
episode = get_episode(label_0_instructions); if (segment.type === SegmentType.Instructions && segment.label === 0) {
area_variants = get_area_variants(dat, episode, label_0_instructions, lenient); label_0_segment = segment;
break;
}
}
if (label_0_segment) {
episode = get_episode(label_0_segment.instructions);
area_variants = get_area_variants(dat, episode, label_0_segment.instructions, lenient);
} else { } else {
logger.warn(`Index ${bin.labels.get(0)} for label 0 is invalid.`); logger.warn(`No instruction for label 0 found.`);
} }
} else { } else {
logger.warn(`Label 0 not found.`); logger.warn("File contains no instruction labels.");
}
} else {
logger.warn("File contains no labels.");
} }
return new Quest( return new Quest(
@ -91,8 +100,7 @@ export function parse_quest(cursor: Cursor, lenient: boolean = false): Quest | u
parse_obj_data(dat.objs), parse_obj_data(dat.objs),
parse_npc_data(episode, dat.npcs), parse_npc_data(episode, dat.npcs),
dat.unknowns, dat.unknowns,
bin.labels, bin.object_code,
bin.instructions,
bin.shop_items bin.shop_items
); );
} }
@ -110,8 +118,7 @@ export function write_quest_qst(quest: Quest, file_name: string): ArrayBuffer {
quest.name, quest.name,
quest.short_description, quest.short_description,
quest.long_description, quest.long_description,
quest.labels, quest.object_code,
quest.instructions,
quest.shop_items quest.shop_items
) )
); );
@ -140,7 +147,7 @@ export function write_quest_qst(quest: Quest, file_name: string): ArrayBuffer {
/** /**
* Defaults to episode I. * Defaults to episode I.
*/ */
function get_episode(func_0_instructions: Instruction[]): number { function get_episode(func_0_instructions: Instruction[]): Episode {
const set_episode = func_0_instructions.find( const set_episode = func_0_instructions.find(
instruction => instruction.opcode === Opcode.set_episode instruction => instruction.opcode === Opcode.set_episode
); );
@ -149,11 +156,11 @@ function get_episode(func_0_instructions: Instruction[]): number {
switch (set_episode.args[0].value) { switch (set_episode.args[0].value) {
default: default:
case 0: case 0:
return 1; return Episode.I;
case 1: case 1:
return 2; return Episode.II;
case 2: case 2:
return 4; return Episode.IV;
} }
} else { } else {
logger.debug("Function 0 has no set_episode instruction."); logger.debug("Function 0 has no set_episode instruction.");

101
src/data_formats/parsing/quest/opcodes.ts
View File

@ -23,17 +23,25 @@ export enum Type {
*/ */
F32, F32,
/** /**
* Register reference * Register reference.
*/ */
Register, Register,
/** /**
* Arbitrary amount of u8 arguments. * Named reference to an instruction.
*/
ILabel,
/**
* Named reference to a data segment.
*/
DLabel,
/**
* Arbitrary amount of U8 arguments.
*/ */
U8Var, U8Var,
/** /**
* Arbitrary amount of u16 arguments. * Arbitrary amount of ILabel arguments.
*/ */
U16Var, ILabelVar,
/** /**
* String of arbitrary size. * String of arbitrary size.
*/ */
@ -53,7 +61,7 @@ export class Opcode {
/** /**
* Byte size of the instruction code, either 1 or 2. * Byte size of the instruction code, either 1 or 2.
*/ */
readonly code_size: number; readonly size: number;
constructor( constructor(
/** /**
@ -75,7 +83,7 @@ export class Opcode {
*/ */
readonly stack_params: Param[] readonly stack_params: Param[]
) { ) {
this.code_size = this.code < 256 ? 1 : 2; this.size = this.code < 256 ? 1 : 2;
} }
static readonly nop = (OPCODES[0x00] = new Opcode(0x00, "nop", [], false, [])); static readonly nop = (OPCODES[0x00] = new Opcode(0x00, "nop", [], false, []));
@ -87,7 +95,7 @@ export class Opcode {
static readonly thread = (OPCODES[0x04] = new Opcode( static readonly thread = (OPCODES[0x04] = new Opcode(
0x04, 0x04,
"thread", "thread",
[{ type: Type.U16 }], [{ type: Type.ILabel }],
false, false,
[] []
)); ));
@ -96,7 +104,7 @@ export class Opcode {
static readonly va_call = (OPCODES[0x07] = new Opcode( static readonly va_call = (OPCODES[0x07] = new Opcode(
0x07, 0x07,
"va_call", "va_call",
[{ type: Type.U16 }], [{ type: Type.ILabel }],
false, false,
[] []
)); ));
@ -291,182 +299,182 @@ export class Opcode {
static readonly jmp = (OPCODES[0x28] = new Opcode( static readonly jmp = (OPCODES[0x28] = new Opcode(
0x28, 0x28,
"jmp", "jmp",
[{ type: Type.U16 }], [{ type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly call = (OPCODES[0x29] = new Opcode( static readonly call = (OPCODES[0x29] = new Opcode(
0x29, 0x29,
"call", "call",
[{ type: Type.U16 }], [{ type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmp_on = (OPCODES[0x2a] = new Opcode( static readonly jmp_on = (OPCODES[0x2a] = new Opcode(
0x2a, 0x2a,
"jmp_on", "jmp_on",
[{ type: Type.U16 }, { type: Type.U8Var }], [{ type: Type.ILabel }, { type: Type.U8Var }],
false, false,
[] []
)); ));
static readonly jmp_off = (OPCODES[0x2b] = new Opcode( static readonly jmp_off = (OPCODES[0x2b] = new Opcode(
0x2b, 0x2b,
"jmp_off", "jmp_off",
[{ type: Type.U16 }, { type: Type.U8Var }], [{ type: Type.ILabel }, { type: Type.U8Var }],
false, false,
[] []
)); ));
static readonly jmp_e = (OPCODES[0x2c] = new Opcode( static readonly jmp_e = (OPCODES[0x2c] = new Opcode(
0x2c, 0x2c,
"jmp_=", "jmp_=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmpi_e = (OPCODES[0x2d] = new Opcode( static readonly jmpi_e = (OPCODES[0x2d] = new Opcode(
0x2d, 0x2d,
"jmpi_=", "jmpi_=",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmp_ne = (OPCODES[0x2e] = new Opcode( static readonly jmp_ne = (OPCODES[0x2e] = new Opcode(
0x2e, 0x2e,
"jmp_!=", "jmp_!=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmpi_ne = (OPCODES[0x2f] = new Opcode( static readonly jmpi_ne = (OPCODES[0x2f] = new Opcode(
0x2f, 0x2f,
"jmpi_!=", "jmpi_!=",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly ujmp_g = (OPCODES[0x30] = new Opcode( static readonly ujmp_g = (OPCODES[0x30] = new Opcode(
0x30, 0x30,
"ujmp_>", "ujmp_>",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly ujmpi_g = (OPCODES[0x31] = new Opcode( static readonly ujmpi_g = (OPCODES[0x31] = new Opcode(
0x31, 0x31,
"ujmpi_>", "ujmpi_>",
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.U32 }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmp_g = (OPCODES[0x32] = new Opcode( static readonly jmp_g = (OPCODES[0x32] = new Opcode(
0x32, 0x32,
"jmp_>", "jmp_>",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmpi_g = (OPCODES[0x33] = new Opcode( static readonly jmpi_g = (OPCODES[0x33] = new Opcode(
0x33, 0x33,
"jmpi_>", "jmpi_>",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly ujmp_l = (OPCODES[0x34] = new Opcode( static readonly ujmp_l = (OPCODES[0x34] = new Opcode(
0x34, 0x34,
"ujmp_<", "ujmp_<",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly ujmpi_l = (OPCODES[0x35] = new Opcode( static readonly ujmpi_l = (OPCODES[0x35] = new Opcode(
0x35, 0x35,
"ujmpi_<", "ujmpi_<",
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.U32 }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmp_l = (OPCODES[0x36] = new Opcode( static readonly jmp_l = (OPCODES[0x36] = new Opcode(
0x36, 0x36,
"jmp_<", "jmp_<",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmpi_l = (OPCODES[0x37] = new Opcode( static readonly jmpi_l = (OPCODES[0x37] = new Opcode(
0x37, 0x37,
"jmpi_<", "jmpi_<",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly ujmp_ge = (OPCODES[0x38] = new Opcode( static readonly ujmp_ge = (OPCODES[0x38] = new Opcode(
0x38, 0x38,
"ujmp_>=", "ujmp_>=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly ujmpi_ge = (OPCODES[0x39] = new Opcode( static readonly ujmpi_ge = (OPCODES[0x39] = new Opcode(
0x39, 0x39,
"ujmpi_>=", "ujmpi_>=",
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.U32 }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmp_ge = (OPCODES[0x3a] = new Opcode( static readonly jmp_ge = (OPCODES[0x3a] = new Opcode(
0x3a, 0x3a,
"jmp_>=", "jmp_>=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmpi_ge = (OPCODES[0x3b] = new Opcode( static readonly jmpi_ge = (OPCODES[0x3b] = new Opcode(
0x3b, 0x3b,
"jmpi_>=", "jmpi_>=",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly ujmp_le = (OPCODES[0x3c] = new Opcode( static readonly ujmp_le = (OPCODES[0x3c] = new Opcode(
0x3c, 0x3c,
"ujmp_<=", "ujmp_<=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly ujmpi_le = (OPCODES[0x3d] = new Opcode( static readonly ujmpi_le = (OPCODES[0x3d] = new Opcode(
0x3d, 0x3d,
"ujmpi_<=", "ujmpi_<=",
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.U32 }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmp_le = (OPCODES[0x3e] = new Opcode( static readonly jmp_le = (OPCODES[0x3e] = new Opcode(
0x3e, 0x3e,
"jmp_<=", "jmp_<=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly jmpi_le = (OPCODES[0x3f] = new Opcode( static readonly jmpi_le = (OPCODES[0x3f] = new Opcode(
0x3f, 0x3f,
"jmpi_<=", "jmpi_<=",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly switch_jmp = (OPCODES[0x40] = new Opcode( static readonly switch_jmp = (OPCODES[0x40] = new Opcode(
0x40, 0x40,
"switch_jmp", "switch_jmp",
[{ type: Type.Register }, { type: Type.U16Var }], [{ type: Type.Register }, { type: Type.ILabelVar }],
false, false,
[] []
)); ));
static readonly switch_call = (OPCODES[0x41] = new Opcode( static readonly switch_call = (OPCODES[0x41] = new Opcode(
0x41, 0x41,
"switch_call", "switch_call",
[{ type: Type.Register }, { type: Type.U16Var }], [{ type: Type.Register }, { type: Type.ILabelVar }],
false, false,
[] []
)); ));
@ -842,7 +850,7 @@ export class Opcode {
"set_floor_handler", "set_floor_handler",
[], [],
false, false,
[{ type: Type.U32 }, { type: Type.U16 }] [{ type: Type.U32 }, { type: Type.ILabel }]
)); ));
static readonly clr_floor_handler = (OPCODES[0x96] = new Opcode( static readonly clr_floor_handler = (OPCODES[0x96] = new Opcode(
0x96, 0x96,
@ -876,14 +884,14 @@ export class Opcode {
static readonly set_qt_failure = (OPCODES[0xa1] = new Opcode( static readonly set_qt_failure = (OPCODES[0xa1] = new Opcode(
0xa1, 0xa1,
"set_qt_failure", "set_qt_failure",
[{ type: Type.U16 }], [{ type: Type.ILabel }],
false, false,
[] []
)); ));
static readonly set_qt_success = (OPCODES[0xa2] = new Opcode( static readonly set_qt_success = (OPCODES[0xa2] = new Opcode(
0xa2, 0xa2,
"set_qt_success", "set_qt_success",
[{ type: Type.U16 }], [{ type: Type.ILabel }],
false, false,
[] []
)); ));
@ -904,7 +912,7 @@ export class Opcode {
static readonly set_qt_cancel = (OPCODES[0xa5] = new Opcode( static readonly set_qt_cancel = (OPCODES[0xa5] = new Opcode(
0xa5, 0xa5,
"set_qt_cancel", "set_qt_cancel",
[{ type: Type.U16 }], [{ type: Type.ILabel }],
false, false,
[] []
)); ));
@ -937,7 +945,7 @@ export class Opcode {
static readonly thread_stg = (OPCODES[0xb1] = new Opcode( static readonly thread_stg = (OPCODES[0xb1] = new Opcode(
0xb1, 0xb1,
"thread_stg", "thread_stg",
[{ type: Type.U16 }], [{ type: Type.ILabel }],
false, false,
[] []
)); ));
@ -996,7 +1004,7 @@ export class Opcode {
static readonly set_qt_exit = (OPCODES[0xba] = new Opcode( static readonly set_qt_exit = (OPCODES[0xba] = new Opcode(
0xba, 0xba,
"set_qt_exit", "set_qt_exit",
[{ type: Type.U16 }], [{ type: Type.ILabel }],
false, false,
[] []
)); ));
@ -1060,7 +1068,7 @@ export class Opcode {
"set_quest_board_handler", "set_quest_board_handler",
[], [],
false, false,
[{ type: Type.U32 }, { type: Type.U16 }, { type: Type.String }] [{ type: Type.U32 }, { type: Type.ILabel }, { type: Type.String }]
)); ));
static readonly clear_quest_board_handler = (OPCODES[0xcc] = new Opcode( static readonly clear_quest_board_handler = (OPCODES[0xcc] = new Opcode(
0xcc, 0xcc,
@ -1755,7 +1763,7 @@ export class Opcode {
static readonly get_npc_data = (OPCODES[0xf841] = new Opcode( static readonly get_npc_data = (OPCODES[0xf841] = new Opcode(
0xf841, 0xf841,
"get_npc_data", "get_npc_data",
[{ type: Type.U16 }], [{ type: Type.DLabel }],
false, false,
[] []
)); ));
@ -2819,10 +2827,11 @@ export class Opcode {
{ type: Type.U16 }, { type: Type.U16 },
] ]
)); ));
// TODO: 3rd parameter is a string data reference.
static readonly npc_action_string = (OPCODES[0xf8dc] = new Opcode( static readonly npc_action_string = (OPCODES[0xf8dc] = new Opcode(
0xf8dc, 0xf8dc,
"npc_action_string", "npc_action_string",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }], [{ type: Type.Register }, { type: Type.Register }, { type: Type.DLabel }],
false, false,
[] []
)); ));
@ -2984,7 +2993,7 @@ export class Opcode {
{ type: Type.U32 }, { type: Type.U32 },
{ type: Type.U32 }, { type: Type.U32 },
{ type: Type.Register }, { type: Type.Register },
{ type: Type.U16 }, { type: Type.DLabel },
] ]
)); ));
static readonly particle2 = (OPCODES[0xf8f3] = new Opcode(0xf8f3, "particle2", [], false, [ static readonly particle2 = (OPCODES[0xf8f3] = new Opcode(0xf8f3, "particle2", [], false, [
@ -3221,7 +3230,7 @@ export class Opcode {
"set_palettex_callback", "set_palettex_callback",
[], [],
false, false,
[{ type: Type.Register }, { type: Type.U16 }] [{ type: Type.Register }, { type: Type.ILabel }]
)); ));
static readonly activate_palettex = (OPCODES[0xf915] = new Opcode( static readonly activate_palettex = (OPCODES[0xf915] = new Opcode(
0xf915, 0xf915,
@ -3531,7 +3540,7 @@ export class Opcode {
"prepare_statistic", "prepare_statistic",
[], [],
false, false,
[{ type: Type.U32 }, { type: Type.U16 }, { type: Type.U16 }] [{ type: Type.U32 }, { type: Type.ILabel }, { type: Type.ILabel }]
)); ));
static readonly keyword_detect = (OPCODES[0xf93f] = new Opcode( static readonly keyword_detect = (OPCODES[0xf93f] = new Opcode(
0xf93f, 0xf93f,

14
src/domain/index.ts
View File

@ -1,11 +1,11 @@
import { action, computed, observable } from "mobx"; import { action, computed, observable } from "mobx";
import { Segment } from "../data_formats/parsing/quest/bin";
import { DatUnknown } from "../data_formats/parsing/quest/dat"; import { DatUnknown } from "../data_formats/parsing/quest/dat";
import { Vec3 } from "../data_formats/vector"; import { Vec3 } from "../data_formats/vector";
import { enum_values } from "../enums"; import { enum_values } from "../enums";
import { ItemType } from "./items"; import { ItemType } from "./items";
import { NpcType } from "./NpcType"; import { NpcType } from "./NpcType";
import { ObjectType } from "./ObjectType"; import { ObjectType } from "./ObjectType";
import { Instruction } from "../data_formats/parsing/quest/bin";
export * from "./items"; export * from "./items";
export * from "./NpcType"; export * from "./NpcType";
@ -152,8 +152,7 @@ export class Quest {
* (Partial) raw DAT data that can't be parsed yet by Phantasmal. * (Partial) raw DAT data that can't be parsed yet by Phantasmal.
*/ */
readonly dat_unknowns: DatUnknown[]; readonly dat_unknowns: DatUnknown[];
readonly labels: Map<number, number>; readonly object_code: Segment[];
readonly instructions: Instruction[];
readonly shop_items: number[]; readonly shop_items: number[];
constructor( constructor(
@ -167,8 +166,7 @@ export class Quest {
objects: QuestObject[], objects: QuestObject[],
npcs: QuestNpc[], npcs: QuestNpc[],
dat_unknowns: DatUnknown[], dat_unknowns: DatUnknown[],
labels: Map<number, number>, object_code: Segment[],
instructions: Instruction[],
shop_items: number[] shop_items: number[]
) { ) {
check_episode(episode); check_episode(episode);
@ -176,8 +174,7 @@ export class Quest {
if (!objects || !(objects instanceof Array)) throw new Error("objs is required."); if (!objects || !(objects instanceof Array)) throw new Error("objs is required.");
if (!npcs || !(npcs instanceof Array)) throw new Error("npcs is required."); if (!npcs || !(npcs instanceof Array)) throw new Error("npcs is required.");
if (!dat_unknowns) throw new Error("dat_unknowns is required."); if (!dat_unknowns) throw new Error("dat_unknowns is required.");
if (!labels) throw new Error("labels is required."); if (!object_code) throw new Error("object_code is required.");
if (!instructions) throw new Error("instructions is required.");
if (!shop_items) throw new Error("shop_items is required."); if (!shop_items) throw new Error("shop_items is required.");
this.set_id(id); this.set_id(id);
@ -190,8 +187,7 @@ export class Quest {
this.objects = objects; this.objects = objects;
this.npcs = npcs; this.npcs = npcs;
this.dat_unknowns = dat_unknowns; this.dat_unknowns = dat_unknowns;
this.labels = labels; this.object_code = object_code;
this.instructions = instructions;
this.shop_items = shop_items; this.shop_items = shop_items;
} }
} }

25
src/scripting/Assembler.ts → src/scripting/AssemblyAnalyser.ts
View File

@ -1,26 +1,24 @@
import { observable } from "mobx"; import { observable } from "mobx";
import { editor } from "monaco-editor"; import { editor } from "monaco-editor";
import AssemblyWorker from "worker-loader!./assembly_worker"; import AssemblyWorker from "worker-loader!./assembly_worker";
import { Instruction } from "../data_formats/parsing/quest/bin"; import { Segment } from "../data_formats/parsing/quest/bin";
import { AssemblyChangeInput, NewAssemblyInput, ScriptWorkerOutput } from "./assembler_messages"; import { AssemblyChangeInput, NewAssemblyInput, ScriptWorkerOutput } from "./assembler_messages";
import { AssemblyError } from "./assembly"; import { AssemblyError } from "./assembly";
import { disassemble } from "./disassembly"; import { disassemble } from "./disassembly";
export class Assembler { export class AssemblyAnalyser {
@observable errors: AssemblyError[] = []; @observable errors: AssemblyError[] = [];
private worker = new AssemblyWorker(); private worker = new AssemblyWorker();
private instructions: Instruction[] = []; private object_code: Segment[] = [];
private labels: Map<number, number> = new Map();
constructor() { constructor() {
this.worker.onmessage = this.process_worker_message; this.worker.onmessage = this.process_worker_message;
} }
disassemble(instructions: Instruction[], labels: Map<number, number>): string[] { disassemble(object_code: Segment[]): string[] {
this.instructions = instructions; this.object_code = object_code;
this.labels = labels; const assembly = disassemble(object_code);
const assembly = disassemble(instructions, labels);
const message: NewAssemblyInput = { type: "new_assembly_input", assembly }; const message: NewAssemblyInput = { type: "new_assembly_input", assembly };
this.worker.postMessage(message); this.worker.postMessage(message);
return assembly; return assembly;
@ -38,15 +36,8 @@ export class Assembler {
private process_worker_message = (e: MessageEvent): void => { private process_worker_message = (e: MessageEvent): void => {
const message: ScriptWorkerOutput = e.data; const message: ScriptWorkerOutput = e.data;
if (message.type === "new_errors_output") { if (message.type === "new_object_code_output") {
this.instructions.splice(0, this.instructions.length, ...message.instructions); this.object_code.splice(0, this.object_code.length, ...message.object_code);
this.labels.clear();
for (const [l, i] of message.labels) {
this.labels.set(l, i);
}
this.errors = message.errors; this.errors = message.errors;
} }
}; };

11
src/scripting/assembler_messages.ts
View File

@ -1,5 +1,5 @@
import { editor } from "monaco-editor"; import { editor } from "monaco-editor";
import { Instruction } from "../data_formats/parsing/quest/bin"; import { Segment } from "../data_formats/parsing/quest/bin";
import { AssemblyError } from "./assembly"; import { AssemblyError } from "./assembly";
export type ScriptWorkerInput = NewAssemblyInput | AssemblyChangeInput; export type ScriptWorkerInput = NewAssemblyInput | AssemblyChangeInput;
@ -14,11 +14,10 @@ export type AssemblyChangeInput = {
readonly changes: editor.IModelContentChange[]; readonly changes: editor.IModelContentChange[];
}; };
export type ScriptWorkerOutput = NewErrorsOutput; export type ScriptWorkerOutput = NewObjectCodeOutput;
export type NewErrorsOutput = { export type NewObjectCodeOutput = {
readonly type: "new_errors_output"; readonly type: "new_object_code_output";
readonly instructions: Instruction[]; readonly object_code: Segment[];
readonly labels: Map<number, number>;
readonly errors: AssemblyError[]; readonly errors: AssemblyError[];
}; };

73
src/scripting/assembly.test.ts
View File

@ -1,8 +1,8 @@
import { InstructionSegment, Opcode, SegmentType } from "../data_formats/parsing/quest/bin";
import { assemble } from "./assembly"; import { assemble } from "./assembly";
import { Opcode } from "../data_formats/parsing/quest/bin";
test("", () => { test("", () => {
const { instructions, labels, errors } = assemble( const { object_code, errors } = assemble(
` `
0: set_episode 0 0: set_episode 0
bb_map_designate 1, 2, 3, 4 bb_map_designate 1, 2, 3, 4
@ -17,46 +17,59 @@ test("", () => {
expect(errors).toEqual([]); expect(errors).toEqual([]);
expect(instructions.length).toBe(13); expect(object_code.length).toBe(3);
expect(instructions[0].opcode).toBe(Opcode.set_episode); const segment_0 = object_code[0] as InstructionSegment;
expect(instructions[0].args).toEqual([{ value: 0, size: 4 }]);
expect(instructions[1].opcode).toBe(Opcode.bb_map_designate); expect(segment_0.type).toBe(SegmentType.Instructions);
expect(instructions[1].args).toEqual([ expect(segment_0.instructions.length).toBe(9);
expect(segment_0.instructions[0].opcode).toBe(Opcode.set_episode);
expect(segment_0.instructions[0].args).toEqual([{ value: 0, size: 4 }]);
expect(segment_0.instructions[1].opcode).toBe(Opcode.bb_map_designate);
expect(segment_0.instructions[1].args).toEqual([
{ value: 1, size: 1 }, { value: 1, size: 1 },
{ value: 2, size: 2 }, { value: 2, size: 2 },
{ value: 3, size: 1 }, { value: 3, size: 1 },
{ value: 4, size: 1 }, { value: 4, size: 1 },
]); ]);
expect(instructions[2].opcode).toBe(Opcode.arg_pushl); expect(segment_0.instructions[2].opcode).toBe(Opcode.arg_pushl);
expect(instructions[2].args).toEqual([{ value: 0, size: 4 }]); expect(segment_0.instructions[2].args).toEqual([{ value: 0, size: 4 }]);
expect(instructions[3].opcode).toBe(Opcode.arg_pushw); expect(segment_0.instructions[3].opcode).toBe(Opcode.arg_pushw);
expect(instructions[3].args).toEqual([{ value: 150, size: 2 }]); expect(segment_0.instructions[3].args).toEqual([{ value: 150, size: 2 }]);
expect(instructions[4].opcode).toBe(Opcode.set_floor_handler); expect(segment_0.instructions[4].opcode).toBe(Opcode.set_floor_handler);
expect(instructions[4].args).toEqual([]); expect(segment_0.instructions[4].args).toEqual([]);
expect(instructions[5].opcode).toBe(Opcode.arg_pushl); expect(segment_0.instructions[5].opcode).toBe(Opcode.arg_pushl);
expect(instructions[5].args).toEqual([{ value: 1, size: 4 }]); expect(segment_0.instructions[5].args).toEqual([{ value: 1, size: 4 }]);
expect(instructions[6].opcode).toBe(Opcode.arg_pushw); expect(segment_0.instructions[6].opcode).toBe(Opcode.arg_pushw);
expect(instructions[6].args).toEqual([{ value: 151, size: 2 }]); expect(segment_0.instructions[6].args).toEqual([{ value: 151, size: 2 }]);
expect(instructions[7].opcode).toBe(Opcode.set_floor_handler); expect(segment_0.instructions[7].opcode).toBe(Opcode.set_floor_handler);
expect(instructions[7].args).toEqual([]); expect(segment_0.instructions[7].args).toEqual([]);
expect(instructions[8].opcode).toBe(Opcode.ret); expect(segment_0.instructions[8].opcode).toBe(Opcode.ret);
expect(instructions[8].args).toEqual([]); expect(segment_0.instructions[8].args).toEqual([]);
expect(instructions[9].opcode).toBe(Opcode.arg_pushl); const segment_1 = object_code[1] as InstructionSegment;
expect(instructions[9].args).toEqual([{ value: 1, size: 4 }]);
expect(instructions[10].opcode).toBe(Opcode.set_mainwarp);
expect(instructions[10].args).toEqual([]);
expect(instructions[11].opcode).toBe(Opcode.ret); expect(segment_1.type).toBe(SegmentType.Instructions);
expect(instructions[11].args).toEqual([]); expect(segment_1.instructions.length).toBe(3);
expect(instructions[12].opcode).toBe(Opcode.ret); expect(segment_1.instructions[0].opcode).toBe(Opcode.arg_pushl);
expect(instructions[12].args).toEqual([]); expect(segment_1.instructions[0].args).toEqual([{ value: 1, size: 4 }]);
expect(segment_1.instructions[1].opcode).toBe(Opcode.set_mainwarp);
expect(segment_1.instructions[1].args).toEqual([]);
expect(labels).toEqual(new Map([[0, 0], [150, 9], [151, 12]])); expect(segment_1.instructions[2].opcode).toBe(Opcode.ret);
expect(segment_1.instructions[2].args).toEqual([]);
const segment_2 = object_code[2] as InstructionSegment;
expect(segment_2.type).toBe(SegmentType.Instructions);
expect(segment_2.instructions.length).toBe(1);
expect(segment_2.instructions[0].opcode).toBe(Opcode.ret);
expect(segment_2.instructions[0].args).toEqual([]);
}); });

322
src/scripting/assembly.ts
View File

@ -1,10 +1,13 @@
import { import {
Instruction,
OPCODES_BY_MNEMONIC,
Arg, Arg,
Type, Instruction,
InstructionSegment,
Opcode, Opcode,
OPCODES_BY_MNEMONIC,
Param, Param,
Segment,
SegmentType,
Type,
} from "../data_formats/parsing/quest/bin"; } from "../data_formats/parsing/quest/bin";
export type AssemblyError = { export type AssemblyError = {
@ -18,28 +21,50 @@ export function assemble(
assembly: string[], assembly: string[],
manual_stack: boolean = false manual_stack: boolean = false
): { ): {
instructions: Instruction[]; object_code: Segment[];
labels: Map<number, number>;
errors: AssemblyError[]; errors: AssemblyError[];
} { } {
const errors: AssemblyError[] = []; return new Assembler(assembly, manual_stack).assemble();
const instructions: Instruction[] = []; }
const labels = new Map<number, number>();
let line_no = 1; type ArgToken = {
col: number;
arg: string;
};
for (const line of assembly) { class Assembler {
private line_no!: number;
private object_code!: Segment[];
private errors!: AssemblyError[];
// Encountered labels.
private labels!: Set<number>;
constructor(private assembly: string[], private manual_stack: boolean) {}
assemble(): {
object_code: Segment[];
errors: AssemblyError[];
} {
this.line_no = 1;
this.object_code = [];
this.errors = [];
this.labels = new Set();
for (const line of this.assembly) {
const match = line.match( const match = line.match(
/^(?<lbl_ws>\s*)(?<lbl>[^\s]+?:)?(?<op_ws>\s*)(?<op>[a-z][a-z0-9_=<>!]*)?(?<args>.*)$/ /^(?<lbl_ws>\s*)(?<lbl>[^\s]+?:)?(?<op_ws>\s*)(?<op>[a-z][a-z0-9_=<>!]*)?(?<args>.*)$/
); );
if (!match || !match.groups || (match.groups.lbl == null && match.groups.op == null)) { if (
!match ||
!match.groups ||
(match.groups.lbl == undefined && match.groups.op == undefined)
) {
const left_trimmed = line.trimLeft(); const left_trimmed = line.trimLeft();
const trimmed = left_trimmed.trimRight(); const trimmed = left_trimmed.trimRight();
if (trimmed.length) { if (trimmed.length) {
errors.push({ this.add_error({
line_no,
col: 1 + line.length - left_trimmed.length, col: 1 + line.length - left_trimmed.length,
length: trimmed.length, length: trimmed.length,
message: "Expected label or instruction.", message: "Expected label or instruction.",
@ -48,48 +73,93 @@ export function assemble(
} else { } else {
const { lbl_ws, lbl, op_ws, op, args } = match.groups; const { lbl_ws, lbl, op_ws, op, args } = match.groups;
if (lbl != null) { if (lbl != undefined) {
this.parse_label(lbl, lbl_ws);
}
if (op != undefined) {
this.parse_instruction(
1 + lbl_ws.length + (lbl ? lbl.length : 0) + op_ws.length,
op,
args
);
}
}
this.line_no++;
}
return {
object_code: this.object_code,
errors: this.errors,
};
}
private add_instruction(opcode: Opcode, args: Arg[]): void {
const { instructions } = this.object_code[
this.object_code.length - 1
] as InstructionSegment;
instructions.push(new Instruction(opcode, args));
}
private add_error({
col,
length,
message,
}: {
col: number;
length: number;
message: string;
}): void {
this.errors.push({
line_no: this.line_no,
col,
length,
message,
});
}
private parse_label(lbl: string, lbl_ws: string): void {
const label = parseInt(lbl.slice(0, -1), 10); const label = parseInt(lbl.slice(0, -1), 10);
if (!isFinite(label) || !/^\d+:$/.test(lbl)) { if (!isFinite(label) || !/^\d+:$/.test(lbl)) {
errors.push({ this.add_error({
line_no,
col: 1 + lbl_ws.length, col: 1 + lbl_ws.length,
length: lbl.length, length: lbl.length,
message: "Invalid label name.", message: "Invalid label name.",
}); });
} else if (labels.has(label)) { } else {
errors.push({ if (this.labels.has(label)) {
line_no, this.add_error({
col: 1 + lbl_ws.length, col: 1 + lbl_ws.length,
length: lbl.length - 1, length: lbl.length - 1,
message: "Duplicate label.", message: "Duplicate label.",
}); });
} else { }
labels.set(label, instructions.length);
this.object_code.push({
type: SegmentType.Instructions,
label,
instructions: [],
});
} }
} }
if (op != null) { private parse_instruction(col: number, op: string, args: string): void {
const opcode = OPCODES_BY_MNEMONIC.get(op); const opcode = OPCODES_BY_MNEMONIC.get(op);
if (!opcode) { if (!opcode) {
errors.push({ this.add_error({
line_no, col,
col: 1 + lbl_ws.length + (lbl ? lbl.length : 0) + op_ws.length,
length: op.length, length: op.length,
message: "Unknown instruction.", message: "Unknown instruction.",
}); });
} else { } else {
const args_col = const args_col = col + (op ? op.length : 0);
1 +
lbl_ws.length +
(lbl ? lbl.length : 0) +
op_ws.length +
(op ? op.length : 0);
const arg_tokens: ArgToken[] = []; const arg_tokens: ArgToken[] = [];
const args_tokenization_ok = tokenize_args(args, args_col, arg_tokens); const args_tokenization_ok = this.tokenize_args(args, args_col, arg_tokens);
const ins_args: Arg[] = []; const ins_args: Arg[] = [];
@ -97,8 +167,7 @@ export function assemble(
const left_trimmed = args.trimLeft(); const left_trimmed = args.trimLeft();
const trimmed = args.trimRight(); const trimmed = args.trimRight();
errors.push({ this.add_error({
line_no,
col: args_col + args.length - left_trimmed.length, col: args_col + args.length - left_trimmed.length,
length: trimmed.length, length: trimmed.length,
message: "Instruction arguments expected.", message: "Instruction arguments expected.",
@ -106,39 +175,25 @@ export function assemble(
} else { } else {
const varargs = const varargs =
opcode.params.findIndex( opcode.params.findIndex(
p => p.type === Type.U8Var || p.type === Type.U16Var p => p.type === Type.U8Var || p.type === Type.ILabelVar
) !== -1; ) !== -1;
const param_count = const param_count =
opcode.params.length + (manual_stack ? 0 : opcode.stack_params.length); opcode.params.length + (this.manual_stack ? 0 : opcode.stack_params.length);
if ( if (varargs ? arg_tokens.length < param_count : arg_tokens.length !== param_count) {
varargs this.add_error({
? arg_tokens.length < param_count col,
: arg_tokens.length !== param_count length: op.length + args.trimRight().length,
) { message: `Expected${varargs ? " at least" : ""} ${param_count} argument${
const left_trimmed = line.trimLeft(); param_count === 1 ? "" : "s"
errors.push({ }, got ${arg_tokens.length}.`,
line_no,
col: 1 + line.length - left_trimmed.length,
length: left_trimmed.length,
message: `Expected${
varargs ? " at least" : ""
} ${param_count} argument${param_count === 1 ? "" : "s"}, got ${
arg_tokens.length
}.`,
}); });
} else if (varargs || arg_tokens.length === opcode.params.length) { } else if (varargs || arg_tokens.length === opcode.params.length) {
parse_args(opcode.params, arg_tokens, ins_args, line_no, errors); this.parse_args(opcode.params, arg_tokens, ins_args);
} else { } else {
const stack_args: Arg[] = []; const stack_args: Arg[] = [];
parse_args( this.parse_args(opcode.stack_params, arg_tokens, stack_args);
opcode.stack_params,
arg_tokens,
stack_args,
line_no,
errors
);
for (let i = 0; i < opcode.stack_params.length; i++) { for (let i = 0; i < opcode.stack_params.length; i++) {
const param = opcode.stack_params[i]; const param = opcode.stack_params[i];
@ -146,29 +201,30 @@ export function assemble(
const col = arg_tokens[i].col; const col = arg_tokens[i].col;
const length = arg_tokens[i].arg.length; const length = arg_tokens[i].arg.length;
if (arg == null) { if (arg == undefined) {
continue; continue;
} }
switch (param.type) { switch (param.type) {
case Type.U8: case Type.U8:
case Type.Register: case Type.Register:
instructions.push(new Instruction(Opcode.arg_pushb, [arg])); this.add_instruction(Opcode.arg_pushb, [arg]);
break; break;
case Type.U16: case Type.U16:
instructions.push(new Instruction(Opcode.arg_pushw, [arg])); case Type.ILabel:
case Type.DLabel:
this.add_instruction(Opcode.arg_pushw, [arg]);
break; break;
case Type.U32: case Type.U32:
case Type.I32: case Type.I32:
case Type.F32: case Type.F32:
instructions.push(new Instruction(Opcode.arg_pushl, [arg])); this.add_instruction(Opcode.arg_pushl, [arg]);
break; break;
case Type.String: case Type.String:
instructions.push(new Instruction(Opcode.arg_pushs, [arg])); this.add_instruction(Opcode.arg_pushs, [arg]);
break; break;
default: default:
errors.push({ this.add_error({
line_no,
col, col,
length, length,
message: `Type ${Type[param.type]} not implemented.`, message: `Type ${Type[param.type]} not implemented.`,
@ -178,27 +234,11 @@ export function assemble(
} }
} }
instructions.push(new Instruction(opcode, ins_args)); this.add_instruction(opcode, ins_args);
}
} }
} }
line_no++; private tokenize_args(arg_str: string, col: number, args: ArgToken[]): boolean {
}
return {
instructions,
labels,
errors,
};
}
type ArgToken = {
col: number;
arg: string;
};
function tokenize_args(arg_str: string, col: number, args: ArgToken[]): boolean {
if (arg_str.trim().length === 0) { if (arg_str.trim().length === 0) {
return true; return true;
} }
@ -220,17 +260,11 @@ function tokenize_args(arg_str: string, col: number, args: ArgToken[]): boolean
arg, arg,
}); });
return tokenize_args(arg_str.slice(match[0].length), col + match[0].length, args); return this.tokenize_args(arg_str.slice(match[0].length), col + match[0].length, args);
} }
} }
function parse_args( private parse_args(params: Param[], arg_tokens: ArgToken[], args: Arg[]): void {
params: Param[],
arg_tokens: ArgToken[],
args: Arg[],
line: number,
errors: AssemblyError[]
): void {
for (let i = 0; i < params.length; i++) { for (let i = 0; i < params.length; i++) {
const param = params[i]; const param = params[i];
const arg_token = arg_tokens[i]; const arg_token = arg_tokens[i];
@ -240,65 +274,58 @@ function parse_args(
switch (param.type) { switch (param.type) {
case Type.U8: case Type.U8:
parse_uint(arg_str, 1, args, line, col, errors); this.parse_uint(arg_str, 1, args, col);
break; break;
case Type.U16: case Type.U16:
parse_uint(arg_str, 2, args, line, col, errors); case Type.ILabel:
case Type.DLabel:
this.parse_uint(arg_str, 2, args, col);
break; break;
case Type.U32: case Type.U32:
parse_uint(arg_str, 4, args, line, col, errors); this.parse_uint(arg_str, 4, args, col);
break; break;
case Type.I32: case Type.I32:
parse_sint(arg_str, 4, args, line, col, errors); this.parse_sint(arg_str, 4, args, col);
break; break;
case Type.F32: case Type.F32:
parse_float(arg_str, args, line, col, errors); this.parse_float(arg_str, args, col);
break; break;
case Type.Register: case Type.Register:
parse_register(arg_str, args, line, col, errors); this.parse_register(arg_str, args, col);
break; break;
case Type.String: case Type.String:
parse_string(arg_str, args, line, col, errors); this.parse_string(arg_str, args, col);
break; break;
case Type.U8Var: case Type.U8Var:
parse_uint_varargs(arg_tokens, i, 1, args, line, errors); this.parse_uint_varargs(arg_tokens, i, 1, args);
return; return;
case Type.U16Var: case Type.ILabelVar:
parse_uint_varargs(arg_tokens, i, 2, args, line, errors); this.parse_uint_varargs(arg_tokens, i, 2, args);
return; return;
default: default:
errors.push({ this.add_error({
line_no: line,
col, col,
length, length,
message: `Type ${Type[param.type]} not implemented.`, message: `Type ${Type[param.type]} not implemented.`,
}); });
break;
} }
} }
} }
function parse_uint( private parse_uint(arg_str: string, size: number, args: Arg[], col: number): void {
arg_str: string,
size: number,
args: Arg[],
line: number,
col: number,
errors: AssemblyError[]
): void {
const bit_size = 8 * size; const bit_size = 8 * size;
const value = parseInt(arg_str, 10); const value = parseInt(arg_str, 10);
const max_value = Math.pow(2, bit_size) - 1; const max_value = Math.pow(2, bit_size) - 1;
if (!/^\d+$/.test(arg_str)) { if (!/^\d+$/.test(arg_str)) {
errors.push({ this.add_error({
line_no: line,
col, col,
length: arg_str.length, length: arg_str.length,
message: `Expected unsigned integer.`, message: `Expected unsigned integer.`,
}); });
} else if (value > max_value) { } else if (value > max_value) {
errors.push({ this.add_error({
line_no: line,
col, col,
length: arg_str.length, length: arg_str.length,
message: `${bit_size}-Bit unsigned integer can't be greater than ${max_value}.`, message: `${bit_size}-Bit unsigned integer can't be greater than ${max_value}.`,
@ -311,36 +338,26 @@ function parse_uint(
} }
} }
function parse_sint( private parse_sint(arg_str: string, size: number, args: Arg[], col: number): void {
arg_str: string,
size: number,
args: Arg[],
line: number,
col: number,
errors: AssemblyError[]
): void {
const bit_size = 8 * size; const bit_size = 8 * size;
const value = parseInt(arg_str, 10); const value = parseInt(arg_str, 10);
const min_value = -Math.pow(2, bit_size - 1); const min_value = -Math.pow(2, bit_size - 1);
const max_value = Math.pow(2, bit_size - 1) - 1; const max_value = Math.pow(2, bit_size - 1) - 1;
if (!/^-?\d+$/.test(arg_str)) { if (!/^-?\d+$/.test(arg_str)) {
errors.push({ this.add_error({
line_no: line,
col, col,
length: arg_str.length, length: arg_str.length,
message: `Expected signed integer.`, message: `Expected signed integer.`,
}); });
} else if (value < min_value) { } else if (value < min_value) {
errors.push({ this.add_error({
line_no: line,
col, col,
length: arg_str.length, length: arg_str.length,
message: `${bit_size}-Bit signed integer can't be less than ${min_value}.`, message: `${bit_size}-Bit signed integer can't be less than ${min_value}.`,
}); });
} else if (value > max_value) { } else if (value > max_value) {
errors.push({ this.add_error({
line_no: line,
col, col,
length: arg_str.length, length: arg_str.length,
message: `${bit_size}-Bit signed integer can't be greater than ${max_value}.`, message: `${bit_size}-Bit signed integer can't be greater than ${max_value}.`,
@ -353,18 +370,11 @@ function parse_sint(
} }
} }
function parse_float( private parse_float(arg_str: string, args: Arg[], col: number): void {
arg_str: string,
args: Arg[],
line: number,
col: number,
errors: AssemblyError[]
): void {
const value = parseFloat(arg_str); const value = parseFloat(arg_str);
if (!Number.isFinite(value)) { if (!Number.isFinite(value)) {
errors.push({ this.add_error({
line_no: line,
col, col,
length: arg_str.length, length: arg_str.length,
message: `Expected floating point number.`, message: `Expected floating point number.`,
@ -377,25 +387,17 @@ function parse_float(
} }
} }
function parse_register( private parse_register(arg_str: string, args: Arg[], col: number): void {
arg_str: string,
args: Arg[],
line: number,
col: number,
errors: AssemblyError[]
): void {
const value = parseInt(arg_str.slice(1), 10); const value = parseInt(arg_str.slice(1), 10);
if (!/^r\d+$/.test(arg_str)) { if (!/^r\d+$/.test(arg_str)) {
errors.push({ this.add_error({
line_no: line,
col, col,
length: arg_str.length, length: arg_str.length,
message: `Expected register reference.`, message: `Expected register reference.`,
}); });
} else if (value > 255) { } else if (value > 255) {
errors.push({ this.add_error({
line_no: line,
col, col,
length: arg_str.length, length: arg_str.length,
message: `Invalid register reference, expected r0-r255.`, message: `Invalid register reference, expected r0-r255.`,
@ -408,16 +410,9 @@ function parse_register(
} }
} }
function parse_string( private parse_string(arg_str: string, args: Arg[], col: number): void {
arg_str: string,
args: Arg[],
line: number,
col: number,
errors: AssemblyError[]
): void {
if (!/^"([^"\\]|\\.)*"$/.test(arg_str)) { if (!/^"([^"\\]|\\.)*"$/.test(arg_str)) {
errors.push({ this.add_error({
line_no: line,
col, col,
length: arg_str.length, length: arg_str.length,
message: `Expected string.`, message: `Expected string.`,
@ -431,17 +426,16 @@ function parse_string(
} }
} }
function parse_uint_varargs( private parse_uint_varargs(
arg_tokens: ArgToken[], arg_tokens: ArgToken[],
index: number, index: number,
size: number, size: number,
args: Arg[], args: Arg[]
line: number,
errors: AssemblyError[]
): void { ): void {
for (; index < arg_tokens.length; index++) { for (; index < arg_tokens.length; index++) {
const arg_token = arg_tokens[index]; const arg_token = arg_tokens[index];
const col = arg_token.col; const col = arg_token.col;
parse_uint(arg_token.arg, size, args, line, col, errors); this.parse_uint(arg_token.arg, size, args, col);
}
} }
} }

6
src/scripting/assembly_worker.ts
View File

@ -1,4 +1,4 @@
import { NewErrorsOutput, ScriptWorkerInput } from "./assembler_messages"; import { NewObjectCodeOutput, ScriptWorkerInput } from "./assembler_messages";
import { assemble } from "./assembly"; import { assemble } from "./assembly";
const ctx: Worker = self as any; const ctx: Worker = self as any;
@ -65,8 +65,8 @@ function process_messages(): void {
} }
} }
const response: NewErrorsOutput = { const response: NewObjectCodeOutput = {
type: "new_errors_output", type: "new_object_code_output",
...assemble(lines), ...assemble(lines),
}; };
ctx.postMessage(response); ctx.postMessage(response);

49
src/scripting/disassembly.ts
View File

@ -1,48 +1,49 @@
import { Arg, Instruction, Param, Type } from "../data_formats/parsing/quest/bin"; import { Arg, Param, Segment, SegmentType, Type } from "../data_formats/parsing/quest/bin";
/** /**
* @param manual_stack If true, will ouput stack management instructions (argpush variants). Otherwise stack management instructions will not be output and their arguments will be output as arguments to the instruction that pops them from the stack. * @param manual_stack If true, will output stack management instructions (argpush variants). Otherwise the arguments of stack management instructions will be output as arguments to the instruction that pops them from the stack.
*/ */
export function disassemble( export function disassemble(object_code: Segment[], manual_stack: boolean = false): string[] {
instructions: Instruction[],
labels: Map<number, number>,
manual_stack: boolean = false
): string[] {
const lines: string[] = []; const lines: string[] = [];
const index_to_label = new Map([...labels.entries()].map(([l, i]) => [i, l]));
const stack: Arg[] = []; const stack: Arg[] = [];
for (let i = 0; i < instructions.length; ++i) { for (const segment of object_code) {
const ins = instructions[i]; if (segment.type === SegmentType.Data) {
const label = index_to_label.get(i); continue;
}
if (!manual_stack && ins.opcode.push_stack) { if (segment.label !== -1) {
stack.push(...ins.args); lines.push(`${segment.label}:`);
}
for (const instruction of segment.instructions) {
if (!manual_stack && instruction.opcode.push_stack) {
stack.push(...instruction.args);
} else { } else {
let args = args_to_strings(ins.opcode.params, ins.args); let args = args_to_strings(instruction.opcode.params, instruction.args);
if (!manual_stack) { if (!manual_stack) {
args.push( args.push(
...args_to_strings( ...args_to_strings(
ins.opcode.stack_params, instruction.opcode.stack_params,
stack.splice( stack.splice(
Math.max(0, stack.length - ins.opcode.stack_params.length), Math.max(0, stack.length - instruction.opcode.stack_params.length),
ins.opcode.stack_params.length instruction.opcode.stack_params.length
) )
) )
); );
} }
if (label != null) { lines.push(
lines.push(`${label}:`); " " +
instruction.opcode.mnemonic +
(args.length ? " " + args.join(", ") : "")
);
} }
lines.push(" " + ins.opcode.mnemonic + (args.length ? " " + args.join(", ") : ""));
} }
} }
// Ensure newline. // Ensure newline at the end.
if (lines.length) { if (lines.length) {
lines.push(""); lines.push("");
} }
@ -64,7 +65,7 @@ function args_to_strings(params: Param[], args: Arg[]): string[] {
switch (type) { switch (type) {
case Type.U8Var: case Type.U8Var:
case Type.U16Var: case Type.ILabelVar:
for (; i < args.length; i++) { for (; i < args.length; i++) {
arg_strings.push(args[i].value.toString()); arg_strings.push(args[i].value.toString());
} }

8
src/ui/quest_editor/AssemblyEditorComponent.tsx
View File

@ -3,7 +3,7 @@ import { editor, languages, MarkerSeverity } from "monaco-editor";
import React, { Component, createRef, ReactNode } from "react"; import React, { Component, createRef, ReactNode } from "react";
import { AutoSizer } from "react-virtualized"; import { AutoSizer } from "react-virtualized";
import { OPCODES } from "../../data_formats/parsing/quest/bin"; import { OPCODES } from "../../data_formats/parsing/quest/bin";
import { Assembler } from "../../scripting/Assembler"; import { AssemblyAnalyser } from "../../scripting/AssemblyAnalyser";
import { quest_editor_store } from "../../stores/QuestEditorStore"; import { quest_editor_store } from "../../stores/QuestEditorStore";
import { Action } from "../../undo"; import { Action } from "../../undo";
import styles from "./AssemblyEditorComponent.css"; import styles from "./AssemblyEditorComponent.css";
@ -130,7 +130,7 @@ type MonacoProps = {
class MonacoComponent extends Component<MonacoProps> { class MonacoComponent extends Component<MonacoProps> {
private div_ref = createRef<HTMLDivElement>(); private div_ref = createRef<HTMLDivElement>();
private editor?: editor.IStandaloneCodeEditor; private editor?: editor.IStandaloneCodeEditor;
private assembler?: Assembler; private assembler?: AssemblyAnalyser;
private disposers: (() => void)[] = []; private disposers: (() => void)[] = [];
render(): ReactNode { render(): ReactNode {
@ -149,7 +149,7 @@ class MonacoComponent extends Component<MonacoProps> {
wrappingIndent: "indent", wrappingIndent: "indent",
}); });
this.assembler = new Assembler(); this.assembler = new AssemblyAnalyser();
this.disposers.push( this.disposers.push(
this.dispose, this.dispose,
@ -182,7 +182,7 @@ class MonacoComponent extends Component<MonacoProps> {
const quest = quest_editor_store.current_quest; const quest = quest_editor_store.current_quest;
if (quest && this.editor && this.assembler) { if (quest && this.editor && this.assembler) {
const assembly = this.assembler.disassemble(quest.instructions, quest.labels); const assembly = this.assembler.disassemble(quest.object_code);
const model = editor.createModel(assembly.join("\n"), "psoasm"); const model = editor.createModel(assembly.join("\n"), "psoasm");
quest_editor_store.script_undo.action = new Action( quest_editor_store.script_undo.action = new Action(

BIN
test/resources/quest27_e.bin Normal file
View File

Binary file not shown.

BIN
test/resources/quest27_e.qst Normal file
View File

Binary file not shown.