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

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;
}
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 {
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[];
/**
* 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.
*/

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

@ -1,15 +1,15 @@
import { readFileSync } from "fs";
import { Endianness } from "../..";
import { prs_decompress } from "../../compression/prs/decompress";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { BufferCursor } from "../../cursor/BufferCursor";
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.
*/
test("parse_bin and write_bin", () => {
const orig_buffer = readFileSync("test/resources/quest118_e.bin");
function test_quest(path: string) {
const orig_buffer = readFileSync(path);
const orig_bin = prs_decompress(new BufferCursor(orig_buffer, Endianness.Little));
const test_buffer = write_bin(parse_bin(orig_bin));
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);
}
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");
});

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

@ -1,10 +1,12 @@
import Logger from "js-logger";
import { Endianness } from "../..";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { Cursor } from "../../cursor/Cursor";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
import { WritableCursor } from "../../cursor/WritableCursor";
import { ResizableBuffer } from "../../ResizableBuffer";
import { Opcode, OPCODES, Type } from "./opcodes";
import { number } from "prop-types";
export * from "./opcodes";
@ -17,32 +19,9 @@ export class BinFile {
readonly quest_name: string,
readonly short_description: string,
readonly long_description: string,
/**
* Map of labels to instruction indices.
*/
readonly labels: Map<number, number>,
readonly instructions: Instruction[],
readonly object_code: Segment[],
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];
this.param_to_args[i] = [];
if (arg == null) {
if (arg == undefined) {
break;
}
switch (type) {
case Type.U8Var:
case Type.U16Var:
case Type.ILabelVar:
this.arg_size++;
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.
*/
@ -121,55 +122,68 @@ export function parse_bin(cursor: Cursor, lenient: boolean = false): BinFile {
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
.seek_start(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) {
instruction_size += instruction.size;
for (const segment of segments) {
if (segment.type === SegmentType.Instructions) {
for (const instruction of segment.instructions) {
segments_size += instruction.size;
}
} else {
segments_size += segment.data.byteLength;
}
}
if (object_code.size !== instruction_size) {
throw new Error(
`Expected to parse ${object_code.size} bytes but parsed ${instruction_size} instead.`
);
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);
}
}
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;
// 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;
}
size += instruction.size;
index++;
}
if (index >= instructions.length) {
logger.warn(`Label ${label} offset ${offset} is too large.`);
} else {
labels.set(label, index);
}
logger.warn(
`Label ${label} with offset ${label_offsets[label]} does not point to anything.`
);
}
}
@ -179,22 +193,14 @@ export function parse_bin(cursor: Cursor, lenient: boolean = false): BinFile {
quest_name,
short_description,
long_description,
labels,
instructions,
segments,
shop_items
);
}
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 buffer = new ResizableBuffer(
object_code_offset + 10 * bin.instructions.length + 4 * labels.length
);
const buffer = new ResizableBuffer(object_code_offset + 100 * bin.object_code.length);
const cursor = new ResizableBufferCursor(buffer, Endianness.Little);
cursor.write_u32(object_code_offset);
@ -222,26 +228,14 @@ export function write_bin(bin: BinFile): ArrayBuffer {
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++) {
const index = labels[label];
for (let label = 0; label < label_offsets.length; label++) {
const offset = label_offsets[label];
if (index == null) {
if (offset == undefined) {
cursor.write_i32(-1);
} 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);
}
}
@ -255,11 +249,83 @@ export function write_bin(bin: BinFile): ArrayBuffer {
return cursor.seek_start(0).array_buffer(file_size);
}
function parse_object_code(cursor: Cursor, lenient: boolean): Instruction[] {
const instructions: Instruction[] = [];
function parse_object_code(
cursor: Cursor,
offset_to_labels: Map<number, number[]>,
lenient: boolean
): Segment[] {
const segments: Segment[] = [];
const data_labels = new Set<number>();
try {
let instructions: Instruction[] | undefined;
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();
let opcode_index;
@ -275,15 +341,30 @@ function parse_object_code(cursor: Cursor, lenient: boolean): Instruction[] {
let opcode = OPCODES[opcode_index];
// Parse the arguments.
try {
const args = parse_instruction_arguments(cursor, opcode);
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) {
logger.warn(
`Exception occurred while parsing arguments for instruction ${opcode.mnemonic}.`,
e
);
instructions.push(new Instruction(opcode, []));
if (lenient) {
logger.error(
`Exception occurred while parsing arguments for instruction ${opcode.mnemonic}.`,
e
);
instructions.push(new Instruction(opcode, []));
} else {
throw 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[] {
@ -320,13 +401,19 @@ function parse_instruction_arguments(cursor: Cursor, opcode: Opcode): Arg[] {
case Type.Register:
args.push({ value: cursor.u8(), size: 1 });
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:
{
const arg_size = cursor.u8();
args.push(...cursor.u8_array(arg_size).map(value => ({ value, size: 1 })));
}
break;
case Type.U16Var:
case Type.ILabelVar:
{
const arg_size = cursor.u8();
args.push(...cursor.u16_array(arg_size).map(value => ({ value, size: 2 })));
@ -351,60 +438,84 @@ function parse_instruction_arguments(cursor: Cursor, opcode: Opcode): Arg[] {
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;
// Keep track of label offsets.
const label_offsets: number[] = [];
for (const instruction of instructions) {
const opcode = instruction.opcode;
if (opcode.code_size === 2) {
cursor.write_u8(opcode.code >>> 8);
// Write instructions first.
for (const segment of segments) {
if (segment.label !== -1) {
label_offsets[segment.label] = cursor.position - start_pos;
}
cursor.write_u8(opcode.code & 0xff);
if (segment.type === SegmentType.Instructions) {
for (const instruction of segment.instructions) {
const opcode = instruction.opcode;
for (let i = 0; i < opcode.params.length; i++) {
const param = opcode.params[i];
const args = instruction.param_to_args[i];
const [arg] = args;
if (opcode.size === 2) {
cursor.write_u8(opcode.code >>> 8);
}
switch (param.type) {
case Type.U8:
cursor.write_u8(arg.value);
break;
case Type.U16:
cursor.write_u16(arg.value);
break;
case Type.U32:
cursor.write_u32(arg.value);
break;
case Type.I32:
cursor.write_i32(arg.value);
break;
case Type.F32:
cursor.write_f32(arg.value);
break;
case Type.Register:
cursor.write_u8(arg.value);
break;
case Type.U8Var:
cursor.write_u8(args.length);
cursor.write_u8_array(args.map(arg => arg.value));
break;
case Type.U16Var:
cursor.write_u8(args.length);
cursor.write_u16_array(args.map(arg => arg.value));
break;
case Type.String:
cursor.write_string_utf16(arg.value, arg.size);
break;
default:
throw new Error(
`Parameter type ${Type[param.type]} (${param.type}) not implemented.`
);
cursor.write_u8(opcode.code & 0xff);
for (let i = 0; i < opcode.params.length; i++) {
const param = opcode.params[i];
const args = instruction.param_to_args[i];
const [arg] = args;
switch (param.type) {
case Type.U8:
cursor.write_u8(arg.value);
break;
case Type.U16:
cursor.write_u16(arg.value);
break;
case Type.U32:
cursor.write_u32(arg.value);
break;
case Type.I32:
cursor.write_i32(arg.value);
break;
case Type.F32:
cursor.write_f32(arg.value);
break;
case Type.Register:
cursor.write_u8(arg.value);
break;
case Type.ILabel:
cursor.write_u16(arg.value);
break;
case Type.DLabel:
cursor.write_u16(arg.value);
break;
case Type.U8Var:
cursor.write_u8(args.length);
cursor.write_u8_array(args.map(arg => arg.value));
break;
case Type.ILabelVar:
cursor.write_u8(args.length);
cursor.write_u16_array(args.map(arg => arg.value));
break;
case Type.String:
cursor.write_string_utf16(arg.value, arg.size);
break;
default:
throw new Error(
`Parameter type ${Type[param.type]} (${
param.type
}) not implemented.`
);
}
}
}
} else {
cursor.write_cursor(new ArrayBufferCursor(segment.data, cursor.endianness));
}
}
return cursor.position - start_pos;
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_quest.instructions.length).toBe(orig_quest.instructions.length);
expect(test_quest.labels.size).toBe(orig_quest.labels.size);
expect(test_quest.object_code.length).toBe(orig_quest.object_code.length);
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);
}
});
}

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

@ -1,6 +1,14 @@
import Logger from "js-logger";
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 { prs_compress } from "../../compression/prs/compress";
import { prs_decompress } from "../../compression/prs/decompress";
@ -8,17 +16,17 @@ import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { Cursor } from "../../cursor/Cursor";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
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 { parse_qst, QstContainedFile, write_qst } from "./qst";
import { Opcode } from "./opcodes";
import { parse_qst, QstContainedFile, write_qst } from "./qst";
const logger = Logger.get("data_formats/parsing/quest");
/**
* 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 {
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) {
logger.error("File contains no DAT file.");
return;
@ -63,21 +69,24 @@ export function parse_quest(cursor: Cursor, lenient: boolean = false): Quest | u
let episode = 1;
let area_variants: AreaVariant[] = [];
if (bin.labels.size) {
if (bin.labels.has(0)) {
const label_0_instructions = bin.get_label_instructions(0);
if (bin.object_code.length) {
let label_0_segment: InstructionSegment | undefined;
if (label_0_instructions) {
episode = get_episode(label_0_instructions);
area_variants = get_area_variants(dat, episode, label_0_instructions, lenient);
} else {
logger.warn(`Index ${bin.labels.get(0)} for label 0 is invalid.`);
for (const segment of bin.object_code) {
if (segment.type === SegmentType.Instructions && segment.label === 0) {
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 {
logger.warn(`Label 0 not found.`);
logger.warn(`No instruction for label 0 found.`);
}
} else {
logger.warn("File contains no labels.");
logger.warn("File contains no instruction labels.");
}
return new Quest(
@ -91,8 +100,7 @@ export function parse_quest(cursor: Cursor, lenient: boolean = false): Quest | u
parse_obj_data(dat.objs),
parse_npc_data(episode, dat.npcs),
dat.unknowns,
bin.labels,
bin.instructions,
bin.object_code,
bin.shop_items
);
}
@ -110,8 +118,7 @@ export function write_quest_qst(quest: Quest, file_name: string): ArrayBuffer {
quest.name,
quest.short_description,
quest.long_description,
quest.labels,
quest.instructions,
quest.object_code,
quest.shop_items
)
);
@ -140,7 +147,7 @@ export function write_quest_qst(quest: Quest, file_name: string): ArrayBuffer {
/**
* 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(
instruction => instruction.opcode === Opcode.set_episode
);
@ -149,11 +156,11 @@ function get_episode(func_0_instructions: Instruction[]): number {
switch (set_episode.args[0].value) {
default:
case 0:
return 1;
return Episode.I;
case 1:
return 2;
return Episode.II;
case 2:
return 4;
return Episode.IV;
}
} else {
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,
/**
* Register reference
* Register reference.
*/
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,
/**
* Arbitrary amount of u16 arguments.
* Arbitrary amount of ILabel arguments.
*/
U16Var,
ILabelVar,
/**
* String of arbitrary size.
*/
@ -53,7 +61,7 @@ export class Opcode {
/**
* Byte size of the instruction code, either 1 or 2.
*/
readonly code_size: number;
readonly size: number;
constructor(
/**
@ -75,7 +83,7 @@ export class Opcode {
*/
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, []));
@ -87,7 +95,7 @@ export class Opcode {
static readonly thread = (OPCODES[0x04] = new Opcode(
0x04,
"thread",
[{ type: Type.U16 }],
[{ type: Type.ILabel }],
false,
[]
));
@ -96,7 +104,7 @@ export class Opcode {
static readonly va_call = (OPCODES[0x07] = new Opcode(
0x07,
"va_call",
[{ type: Type.U16 }],
[{ type: Type.ILabel }],
false,
[]
));
@ -291,182 +299,182 @@ export class Opcode {
static readonly jmp = (OPCODES[0x28] = new Opcode(
0x28,
"jmp",
[{ type: Type.U16 }],
[{ type: Type.ILabel }],
false,
[]
));
static readonly call = (OPCODES[0x29] = new Opcode(
0x29,
"call",
[{ type: Type.U16 }],
[{ type: Type.ILabel }],
false,
[]
));
static readonly jmp_on = (OPCODES[0x2a] = new Opcode(
0x2a,
"jmp_on",
[{ type: Type.U16 }, { type: Type.U8Var }],
[{ type: Type.ILabel }, { type: Type.U8Var }],
false,
[]
));
static readonly jmp_off = (OPCODES[0x2b] = new Opcode(
0x2b,
"jmp_off",
[{ type: Type.U16 }, { type: Type.U8Var }],
[{ type: Type.ILabel }, { type: Type.U8Var }],
false,
[]
));
static readonly jmp_e = (OPCODES[0x2c] = new Opcode(
0x2c,
"jmp_=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false,
[]
));
static readonly jmpi_e = (OPCODES[0x2d] = new Opcode(
0x2d,
"jmpi_=",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false,
[]
));
static readonly jmp_ne = (OPCODES[0x2e] = new Opcode(
0x2e,
"jmp_!=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false,
[]
));
static readonly jmpi_ne = (OPCODES[0x2f] = new Opcode(
0x2f,
"jmpi_!=",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false,
[]
));
static readonly ujmp_g = (OPCODES[0x30] = new Opcode(
0x30,
"ujmp_>",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false,
[]
));
static readonly ujmpi_g = (OPCODES[0x31] = new Opcode(
0x31,
"ujmpi_>",
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.ILabel }],
false,
[]
));
static readonly jmp_g = (OPCODES[0x32] = new Opcode(
0x32,
"jmp_>",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false,
[]
));
static readonly jmpi_g = (OPCODES[0x33] = new Opcode(
0x33,
"jmpi_>",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false,
[]
));
static readonly ujmp_l = (OPCODES[0x34] = new Opcode(
0x34,
"ujmp_<",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false,
[]
));
static readonly ujmpi_l = (OPCODES[0x35] = new Opcode(
0x35,
"ujmpi_<",
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.ILabel }],
false,
[]
));
static readonly jmp_l = (OPCODES[0x36] = new Opcode(
0x36,
"jmp_<",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false,
[]
));
static readonly jmpi_l = (OPCODES[0x37] = new Opcode(
0x37,
"jmpi_<",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false,
[]
));
static readonly ujmp_ge = (OPCODES[0x38] = new Opcode(
0x38,
"ujmp_>=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false,
[]
));
static readonly ujmpi_ge = (OPCODES[0x39] = new Opcode(
0x39,
"ujmpi_>=",
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.ILabel }],
false,
[]
));
static readonly jmp_ge = (OPCODES[0x3a] = new Opcode(
0x3a,
"jmp_>=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false,
[]
));
static readonly jmpi_ge = (OPCODES[0x3b] = new Opcode(
0x3b,
"jmpi_>=",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false,
[]
));
static readonly ujmp_le = (OPCODES[0x3c] = new Opcode(
0x3c,
"ujmp_<=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false,
[]
));
static readonly ujmpi_le = (OPCODES[0x3d] = new Opcode(
0x3d,
"ujmpi_<=",
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.U32 }, { type: Type.ILabel }],
false,
[]
));
static readonly jmp_le = (OPCODES[0x3e] = new Opcode(
0x3e,
"jmp_<=",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.Register }, { type: Type.ILabel }],
false,
[]
));
static readonly jmpi_le = (OPCODES[0x3f] = new Opcode(
0x3f,
"jmpi_<=",
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.I32 }, { type: Type.ILabel }],
false,
[]
));
static readonly switch_jmp = (OPCODES[0x40] = new Opcode(
0x40,
"switch_jmp",
[{ type: Type.Register }, { type: Type.U16Var }],
[{ type: Type.Register }, { type: Type.ILabelVar }],
false,
[]
));
static readonly switch_call = (OPCODES[0x41] = new Opcode(
0x41,
"switch_call",
[{ type: Type.Register }, { type: Type.U16Var }],
[{ type: Type.Register }, { type: Type.ILabelVar }],
false,
[]
));
@ -842,7 +850,7 @@ export class Opcode {
"set_floor_handler",
[],
false,
[{ type: Type.U32 }, { type: Type.U16 }]
[{ type: Type.U32 }, { type: Type.ILabel }]
));
static readonly clr_floor_handler = (OPCODES[0x96] = new Opcode(
0x96,
@ -876,14 +884,14 @@ export class Opcode {
static readonly set_qt_failure = (OPCODES[0xa1] = new Opcode(
0xa1,
"set_qt_failure",
[{ type: Type.U16 }],
[{ type: Type.ILabel }],
false,
[]
));
static readonly set_qt_success = (OPCODES[0xa2] = new Opcode(
0xa2,
"set_qt_success",
[{ type: Type.U16 }],
[{ type: Type.ILabel }],
false,
[]
));
@ -904,7 +912,7 @@ export class Opcode {
static readonly set_qt_cancel = (OPCODES[0xa5] = new Opcode(
0xa5,
"set_qt_cancel",
[{ type: Type.U16 }],
[{ type: Type.ILabel }],
false,
[]
));
@ -937,7 +945,7 @@ export class Opcode {
static readonly thread_stg = (OPCODES[0xb1] = new Opcode(
0xb1,
"thread_stg",
[{ type: Type.U16 }],
[{ type: Type.ILabel }],
false,
[]
));
@ -996,7 +1004,7 @@ export class Opcode {
static readonly set_qt_exit = (OPCODES[0xba] = new Opcode(
0xba,
"set_qt_exit",
[{ type: Type.U16 }],
[{ type: Type.ILabel }],
false,
[]
));
@ -1060,7 +1068,7 @@ export class Opcode {
"set_quest_board_handler",
[],
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(
0xcc,
@ -1755,7 +1763,7 @@ export class Opcode {
static readonly get_npc_data = (OPCODES[0xf841] = new Opcode(
0xf841,
"get_npc_data",
[{ type: Type.U16 }],
[{ type: Type.DLabel }],
false,
[]
));
@ -2819,10 +2827,11 @@ export class Opcode {
{ type: Type.U16 },
]
));
// TODO: 3rd parameter is a string data reference.
static readonly npc_action_string = (OPCODES[0xf8dc] = new Opcode(
0xf8dc,
"npc_action_string",
[{ type: Type.Register }, { type: Type.Register }, { type: Type.U16 }],
[{ type: Type.Register }, { type: Type.Register }, { type: Type.DLabel }],
false,
[]
));
@ -2984,7 +2993,7 @@ export class Opcode {
{ type: Type.U32 },
{ type: Type.U32 },
{ type: Type.Register },
{ type: Type.U16 },
{ type: Type.DLabel },
]
));
static readonly particle2 = (OPCODES[0xf8f3] = new Opcode(0xf8f3, "particle2", [], false, [
@ -3221,7 +3230,7 @@ export class Opcode {
"set_palettex_callback",
[],
false,
[{ type: Type.Register }, { type: Type.U16 }]
[{ type: Type.Register }, { type: Type.ILabel }]
));
static readonly activate_palettex = (OPCODES[0xf915] = new Opcode(
0xf915,
@ -3531,7 +3540,7 @@ export class Opcode {
"prepare_statistic",
[],
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(
0xf93f,

14
src/domain/index.ts
View File

@ -1,11 +1,11 @@
import { action, computed, observable } from "mobx";
import { Segment } from "../data_formats/parsing/quest/bin";
import { DatUnknown } from "../data_formats/parsing/quest/dat";
import { Vec3 } from "../data_formats/vector";
import { enum_values } from "../enums";
import { ItemType } from "./items";
import { NpcType } from "./NpcType";
import { ObjectType } from "./ObjectType";
import { Instruction } from "../data_formats/parsing/quest/bin";
export * from "./items";
export * from "./NpcType";
@ -152,8 +152,7 @@ export class Quest {
* (Partial) raw DAT data that can't be parsed yet by Phantasmal.
*/
readonly dat_unknowns: DatUnknown[];
readonly labels: Map<number, number>;
readonly instructions: Instruction[];
readonly object_code: Segment[];
readonly shop_items: number[];
constructor(
@ -167,8 +166,7 @@ export class Quest {
objects: QuestObject[],
npcs: QuestNpc[],
dat_unknowns: DatUnknown[],
labels: Map<number, number>,
instructions: Instruction[],
object_code: Segment[],
shop_items: number[]
) {
check_episode(episode);
@ -176,8 +174,7 @@ export class Quest {
if (!objects || !(objects instanceof Array)) throw new Error("objs is required.");
if (!npcs || !(npcs instanceof Array)) throw new Error("npcs is required.");
if (!dat_unknowns) throw new Error("dat_unknowns is required.");
if (!labels) throw new Error("labels is required.");
if (!instructions) throw new Error("instructions is required.");
if (!object_code) throw new Error("object_code is required.");
if (!shop_items) throw new Error("shop_items is required.");
this.set_id(id);
@ -190,8 +187,7 @@ export class Quest {
this.objects = objects;
this.npcs = npcs;
this.dat_unknowns = dat_unknowns;
this.labels = labels;
this.instructions = instructions;
this.object_code = object_code;
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 { editor } from "monaco-editor";
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 { AssemblyError } from "./assembly";
import { disassemble } from "./disassembly";
export class Assembler {
export class AssemblyAnalyser {
@observable errors: AssemblyError[] = [];
private worker = new AssemblyWorker();
private instructions: Instruction[] = [];
private labels: Map<number, number> = new Map();
private object_code: Segment[] = [];
constructor() {
this.worker.onmessage = this.process_worker_message;
}
disassemble(instructions: Instruction[], labels: Map<number, number>): string[] {
this.instructions = instructions;
this.labels = labels;
const assembly = disassemble(instructions, labels);
disassemble(object_code: Segment[]): string[] {
this.object_code = object_code;
const assembly = disassemble(object_code);
const message: NewAssemblyInput = { type: "new_assembly_input", assembly };
this.worker.postMessage(message);
return assembly;
@ -38,15 +36,8 @@ export class Assembler {
private process_worker_message = (e: MessageEvent): void => {
const message: ScriptWorkerOutput = e.data;
if (message.type === "new_errors_output") {
this.instructions.splice(0, this.instructions.length, ...message.instructions);
this.labels.clear();
for (const [l, i] of message.labels) {
this.labels.set(l, i);
}
if (message.type === "new_object_code_output") {
this.object_code.splice(0, this.object_code.length, ...message.object_code);
this.errors = message.errors;
}
};

11
src/scripting/assembler_messages.ts
View File

@ -1,5 +1,5 @@
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";
export type ScriptWorkerInput = NewAssemblyInput | AssemblyChangeInput;
@ -14,11 +14,10 @@ export type AssemblyChangeInput = {
readonly changes: editor.IModelContentChange[];
};
export type ScriptWorkerOutput = NewErrorsOutput;
export type ScriptWorkerOutput = NewObjectCodeOutput;
export type NewErrorsOutput = {
readonly type: "new_errors_output";
readonly instructions: Instruction[];
readonly labels: Map<number, number>;
export type NewObjectCodeOutput = {
readonly type: "new_object_code_output";
readonly object_code: Segment[];
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 { Opcode } from "../data_formats/parsing/quest/bin";
test("", () => {
const { instructions, labels, errors } = assemble(
const { object_code, errors } = assemble(
`
0: set_episode 0
bb_map_designate 1, 2, 3, 4
@ -17,46 +17,59 @@ test("", () => {
expect(errors).toEqual([]);
expect(instructions.length).toBe(13);
expect(object_code.length).toBe(3);
expect(instructions[0].opcode).toBe(Opcode.set_episode);
expect(instructions[0].args).toEqual([{ value: 0, size: 4 }]);
const segment_0 = object_code[0] as InstructionSegment;
expect(instructions[1].opcode).toBe(Opcode.bb_map_designate);
expect(instructions[1].args).toEqual([
expect(segment_0.type).toBe(SegmentType.Instructions);
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: 2, size: 2 },
{ value: 3, size: 1 },
{ value: 4, size: 1 },
]);
expect(instructions[2].opcode).toBe(Opcode.arg_pushl);
expect(instructions[2].args).toEqual([{ value: 0, size: 4 }]);
expect(instructions[3].opcode).toBe(Opcode.arg_pushw);
expect(instructions[3].args).toEqual([{ value: 150, size: 2 }]);
expect(instructions[4].opcode).toBe(Opcode.set_floor_handler);
expect(instructions[4].args).toEqual([]);
expect(segment_0.instructions[2].opcode).toBe(Opcode.arg_pushl);
expect(segment_0.instructions[2].args).toEqual([{ value: 0, size: 4 }]);
expect(segment_0.instructions[3].opcode).toBe(Opcode.arg_pushw);
expect(segment_0.instructions[3].args).toEqual([{ value: 150, size: 2 }]);
expect(segment_0.instructions[4].opcode).toBe(Opcode.set_floor_handler);
expect(segment_0.instructions[4].args).toEqual([]);
expect(instructions[5].opcode).toBe(Opcode.arg_pushl);
expect(instructions[5].args).toEqual([{ value: 1, size: 4 }]);
expect(instructions[6].opcode).toBe(Opcode.arg_pushw);
expect(instructions[6].args).toEqual([{ value: 151, size: 2 }]);
expect(instructions[7].opcode).toBe(Opcode.set_floor_handler);
expect(instructions[7].args).toEqual([]);
expect(segment_0.instructions[5].opcode).toBe(Opcode.arg_pushl);
expect(segment_0.instructions[5].args).toEqual([{ value: 1, size: 4 }]);
expect(segment_0.instructions[6].opcode).toBe(Opcode.arg_pushw);
expect(segment_0.instructions[6].args).toEqual([{ value: 151, size: 2 }]);
expect(segment_0.instructions[7].opcode).toBe(Opcode.set_floor_handler);
expect(segment_0.instructions[7].args).toEqual([]);
expect(instructions[8].opcode).toBe(Opcode.ret);
expect(instructions[8].args).toEqual([]);
expect(segment_0.instructions[8].opcode).toBe(Opcode.ret);
expect(segment_0.instructions[8].args).toEqual([]);
expect(instructions[9].opcode).toBe(Opcode.arg_pushl);
expect(instructions[9].args).toEqual([{ value: 1, size: 4 }]);
expect(instructions[10].opcode).toBe(Opcode.set_mainwarp);
expect(instructions[10].args).toEqual([]);
const segment_1 = object_code[1] as InstructionSegment;
expect(instructions[11].opcode).toBe(Opcode.ret);
expect(instructions[11].args).toEqual([]);
expect(segment_1.type).toBe(SegmentType.Instructions);
expect(segment_1.instructions.length).toBe(3);
expect(instructions[12].opcode).toBe(Opcode.ret);
expect(instructions[12].args).toEqual([]);
expect(segment_1.instructions[0].opcode).toBe(Opcode.arg_pushl);
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([]);
});

810
src/scripting/assembly.ts
View File

@ -1,10 +1,13 @@
import {
Instruction,
OPCODES_BY_MNEMONIC,
Arg,
Type,
Instruction,
InstructionSegment,
Opcode,
OPCODES_BY_MNEMONIC,
Param,
Segment,
SegmentType,
Type,
} from "../data_formats/parsing/quest/bin";
export type AssemblyError = {
@ -18,179 +21,10 @@ export function assemble(
assembly: string[],
manual_stack: boolean = false
): {
instructions: Instruction[];
labels: Map<number, number>;
object_code: Segment[];
errors: AssemblyError[];
} {
const errors: AssemblyError[] = [];
const instructions: Instruction[] = [];
const labels = new Map<number, number>();
let line_no = 1;
for (const line of assembly) {
const match = line.match(
/^(?<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)) {
const left_trimmed = line.trimLeft();
const trimmed = left_trimmed.trimRight();
if (trimmed.length) {
errors.push({
line_no,
col: 1 + line.length - left_trimmed.length,
length: trimmed.length,
message: "Expected label or instruction.",
});
}
} else {
const { lbl_ws, lbl, op_ws, op, args } = match.groups;
if (lbl != null) {
const label = parseInt(lbl.slice(0, -1), 10);
if (!isFinite(label) || !/^\d+:$/.test(lbl)) {
errors.push({
line_no,
col: 1 + lbl_ws.length,
length: lbl.length,
message: "Invalid label name.",
});
} else if (labels.has(label)) {
errors.push({
line_no,
col: 1 + lbl_ws.length,
length: lbl.length - 1,
message: "Duplicate label.",
});
} else {
labels.set(label, instructions.length);
}
}
if (op != null) {
const opcode = OPCODES_BY_MNEMONIC.get(op);
if (!opcode) {
errors.push({
line_no,
col: 1 + lbl_ws.length + (lbl ? lbl.length : 0) + op_ws.length,
length: op.length,
message: "Unknown instruction.",
});
} else {
const args_col =
1 +
lbl_ws.length +
(lbl ? lbl.length : 0) +
op_ws.length +
(op ? op.length : 0);
const arg_tokens: ArgToken[] = [];
const args_tokenization_ok = tokenize_args(args, args_col, arg_tokens);
const ins_args: Arg[] = [];
if (!args_tokenization_ok) {
const left_trimmed = args.trimLeft();
const trimmed = args.trimRight();
errors.push({
line_no,
col: args_col + args.length - left_trimmed.length,
length: trimmed.length,
message: "Instruction arguments expected.",
});
} else {
const varargs =
opcode.params.findIndex(
p => p.type === Type.U8Var || p.type === Type.U16Var
) !== -1;
const param_count =
opcode.params.length + (manual_stack ? 0 : opcode.stack_params.length);
if (
varargs
? arg_tokens.length < param_count
: arg_tokens.length !== param_count
) {
const left_trimmed = line.trimLeft();
errors.push({
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) {
parse_args(opcode.params, arg_tokens, ins_args, line_no, errors);
} else {
const stack_args: Arg[] = [];
parse_args(
opcode.stack_params,
arg_tokens,
stack_args,
line_no,
errors
);
for (let i = 0; i < opcode.stack_params.length; i++) {
const param = opcode.stack_params[i];
const arg = stack_args[i];
const col = arg_tokens[i].col;
const length = arg_tokens[i].arg.length;
if (arg == null) {
continue;
}
switch (param.type) {
case Type.U8:
case Type.Register:
instructions.push(new Instruction(Opcode.arg_pushb, [arg]));
break;
case Type.U16:
instructions.push(new Instruction(Opcode.arg_pushw, [arg]));
break;
case Type.U32:
case Type.I32:
case Type.F32:
instructions.push(new Instruction(Opcode.arg_pushl, [arg]));
break;
case Type.String:
instructions.push(new Instruction(Opcode.arg_pushs, [arg]));
break;
default:
errors.push({
line_no,
col,
length,
message: `Type ${Type[param.type]} not implemented.`,
});
}
}
}
}
instructions.push(new Instruction(opcode, ins_args));
}
}
}
line_no++;
}
return {
instructions,
labels,
errors,
};
return new Assembler(assembly, manual_stack).assemble();
}
type ArgToken = {
@ -198,250 +32,410 @@ type ArgToken = {
arg: string;
};
function tokenize_args(arg_str: string, col: number, args: ArgToken[]): boolean {
if (arg_str.trim().length === 0) {
return true;
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(
/^(?<lbl_ws>\s*)(?<lbl>[^\s]+?:)?(?<op_ws>\s*)(?<op>[a-z][a-z0-9_=<>!]*)?(?<args>.*)$/
);
if (
!match ||
!match.groups ||
(match.groups.lbl == undefined && match.groups.op == undefined)
) {
const left_trimmed = line.trimLeft();
const trimmed = left_trimmed.trimRight();
if (trimmed.length) {
this.add_error({
col: 1 + line.length - left_trimmed.length,
length: trimmed.length,
message: "Expected label or instruction.",
});
}
} else {
const { lbl_ws, lbl, op_ws, op, args } = match.groups;
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,
};
}
let match: RegExpMatchArray | null;
private add_instruction(opcode: Opcode, args: Arg[]): void {
const { instructions } = this.object_code[
this.object_code.length - 1
] as InstructionSegment;
if (args.length === 0) {
match = arg_str.match(/^(?<arg_ws>\s+)(?<arg>"([^"\\]|\\.)*"|[^\s,]+)\s*/);
} else {
match = arg_str.match(/^(?<arg_ws>,\s*)(?<arg>"([^"\\]|\\.)*"|[^\s,]+)\s*/);
instructions.push(new Instruction(opcode, args));
}
if (!match || !match.groups) {
return false;
} else {
const { arg_ws, arg } = match.groups;
args.push({
col: col + arg_ws.length,
arg,
private add_error({
col,
length,
message,
}: {
col: number;
length: number;
message: string;
}): void {
this.errors.push({
line_no: this.line_no,
col,
length,
message,
});
return tokenize_args(arg_str.slice(match[0].length), col + match[0].length, args);
}
}
function parse_args(
params: Param[],
arg_tokens: ArgToken[],
args: Arg[],
line: number,
errors: AssemblyError[]
): void {
for (let i = 0; i < params.length; i++) {
const param = params[i];
const arg_token = arg_tokens[i];
const arg_str = arg_token.arg;
const col = arg_token.col;
const length = arg_str.length;
private parse_label(lbl: string, lbl_ws: string): void {
const label = parseInt(lbl.slice(0, -1), 10);
switch (param.type) {
case Type.U8:
parse_uint(arg_str, 1, args, line, col, errors);
break;
case Type.U16:
parse_uint(arg_str, 2, args, line, col, errors);
break;
case Type.U32:
parse_uint(arg_str, 4, args, line, col, errors);
break;
case Type.I32:
parse_sint(arg_str, 4, args, line, col, errors);
break;
case Type.F32:
parse_float(arg_str, args, line, col, errors);
break;
case Type.Register:
parse_register(arg_str, args, line, col, errors);
break;
case Type.String:
parse_string(arg_str, args, line, col, errors);
break;
case Type.U8Var:
parse_uint_varargs(arg_tokens, i, 1, args, line, errors);
return;
case Type.U16Var:
parse_uint_varargs(arg_tokens, i, 2, args, line, errors);
return;
default:
errors.push({
line_no: line,
col,
length,
message: `Type ${Type[param.type]} not implemented.`,
if (!isFinite(label) || !/^\d+:$/.test(lbl)) {
this.add_error({
col: 1 + lbl_ws.length,
length: lbl.length,
message: "Invalid label name.",
});
} else {
if (this.labels.has(label)) {
this.add_error({
col: 1 + lbl_ws.length,
length: lbl.length - 1,
message: "Duplicate label.",
});
}
this.object_code.push({
type: SegmentType.Instructions,
label,
instructions: [],
});
}
}
private parse_instruction(col: number, op: string, args: string): void {
const opcode = OPCODES_BY_MNEMONIC.get(op);
if (!opcode) {
this.add_error({
col,
length: op.length,
message: "Unknown instruction.",
});
} else {
const args_col = col + (op ? op.length : 0);
const arg_tokens: ArgToken[] = [];
const args_tokenization_ok = this.tokenize_args(args, args_col, arg_tokens);
const ins_args: Arg[] = [];
if (!args_tokenization_ok) {
const left_trimmed = args.trimLeft();
const trimmed = args.trimRight();
this.add_error({
col: args_col + args.length - left_trimmed.length,
length: trimmed.length,
message: "Instruction arguments expected.",
});
} else {
const varargs =
opcode.params.findIndex(
p => p.type === Type.U8Var || p.type === Type.ILabelVar
) !== -1;
const param_count =
opcode.params.length + (this.manual_stack ? 0 : opcode.stack_params.length);
if (varargs ? arg_tokens.length < param_count : arg_tokens.length !== param_count) {
this.add_error({
col,
length: op.length + args.trimRight().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) {
this.parse_args(opcode.params, arg_tokens, ins_args);
} else {
const stack_args: Arg[] = [];
this.parse_args(opcode.stack_params, arg_tokens, stack_args);
for (let i = 0; i < opcode.stack_params.length; i++) {
const param = opcode.stack_params[i];
const arg = stack_args[i];
const col = arg_tokens[i].col;
const length = arg_tokens[i].arg.length;
if (arg == undefined) {
continue;
}
switch (param.type) {
case Type.U8:
case Type.Register:
this.add_instruction(Opcode.arg_pushb, [arg]);
break;
case Type.U16:
case Type.ILabel:
case Type.DLabel:
this.add_instruction(Opcode.arg_pushw, [arg]);
break;
case Type.U32:
case Type.I32:
case Type.F32:
this.add_instruction(Opcode.arg_pushl, [arg]);
break;
case Type.String:
this.add_instruction(Opcode.arg_pushs, [arg]);
break;
default:
this.add_error({
col,
length,
message: `Type ${Type[param.type]} not implemented.`,
});
}
}
}
}
this.add_instruction(opcode, ins_args);
}
}
private tokenize_args(arg_str: string, col: number, args: ArgToken[]): boolean {
if (arg_str.trim().length === 0) {
return true;
}
let match: RegExpMatchArray | null;
if (args.length === 0) {
match = arg_str.match(/^(?<arg_ws>\s+)(?<arg>"([^"\\]|\\.)*"|[^\s,]+)\s*/);
} else {
match = arg_str.match(/^(?<arg_ws>,\s*)(?<arg>"([^"\\]|\\.)*"|[^\s,]+)\s*/);
}
if (!match || !match.groups) {
return false;
} else {
const { arg_ws, arg } = match.groups;
args.push({
col: col + arg_ws.length,
arg,
});
return this.tokenize_args(arg_str.slice(match[0].length), col + match[0].length, args);
}
}
private parse_args(params: Param[], arg_tokens: ArgToken[], args: Arg[]): void {
for (let i = 0; i < params.length; i++) {
const param = params[i];
const arg_token = arg_tokens[i];
const arg_str = arg_token.arg;
const col = arg_token.col;
const length = arg_str.length;
switch (param.type) {
case Type.U8:
this.parse_uint(arg_str, 1, args, col);
break;
case Type.U16:
case Type.ILabel:
case Type.DLabel:
this.parse_uint(arg_str, 2, args, col);
break;
case Type.U32:
this.parse_uint(arg_str, 4, args, col);
break;
case Type.I32:
this.parse_sint(arg_str, 4, args, col);
break;
case Type.F32:
this.parse_float(arg_str, args, col);
break;
case Type.Register:
this.parse_register(arg_str, args, col);
break;
case Type.String:
this.parse_string(arg_str, args, col);
break;
case Type.U8Var:
this.parse_uint_varargs(arg_tokens, i, 1, args);
return;
case Type.ILabelVar:
this.parse_uint_varargs(arg_tokens, i, 2, args);
return;
default:
this.add_error({
col,
length,
message: `Type ${Type[param.type]} not implemented.`,
});
break;
}
}
}
private parse_uint(arg_str: string, size: number, args: Arg[], col: number): void {
const bit_size = 8 * size;
const value = parseInt(arg_str, 10);
const max_value = Math.pow(2, bit_size) - 1;
if (!/^\d+$/.test(arg_str)) {
this.add_error({
col,
length: arg_str.length,
message: `Expected unsigned integer.`,
});
} else if (value > max_value) {
this.add_error({
col,
length: arg_str.length,
message: `${bit_size}-Bit unsigned integer can't be greater than ${max_value}.`,
});
} else {
args.push({
value,
size,
});
}
}
private parse_sint(arg_str: string, size: number, args: Arg[], col: number): void {
const bit_size = 8 * size;
const value = parseInt(arg_str, 10);
const min_value = -Math.pow(2, bit_size - 1);
const max_value = Math.pow(2, bit_size - 1) - 1;
if (!/^-?\d+$/.test(arg_str)) {
this.add_error({
col,
length: arg_str.length,
message: `Expected signed integer.`,
});
} else if (value < min_value) {
this.add_error({
col,
length: arg_str.length,
message: `${bit_size}-Bit signed integer can't be less than ${min_value}.`,
});
} else if (value > max_value) {
this.add_error({
col,
length: arg_str.length,
message: `${bit_size}-Bit signed integer can't be greater than ${max_value}.`,
});
} else {
args.push({
value,
size,
});
}
}
private parse_float(arg_str: string, args: Arg[], col: number): void {
const value = parseFloat(arg_str);
if (!Number.isFinite(value)) {
this.add_error({
col,
length: arg_str.length,
message: `Expected floating point number.`,
});
} else {
args.push({
value,
size: 4,
});
}
}
private parse_register(arg_str: string, args: Arg[], col: number): void {
const value = parseInt(arg_str.slice(1), 10);
if (!/^r\d+$/.test(arg_str)) {
this.add_error({
col,
length: arg_str.length,
message: `Expected register reference.`,
});
} else if (value > 255) {
this.add_error({
col,
length: arg_str.length,
message: `Invalid register reference, expected r0-r255.`,
});
} else {
args.push({
value,
size: 1,
});
}
}
private parse_string(arg_str: string, args: Arg[], col: number): void {
if (!/^"([^"\\]|\\.)*"$/.test(arg_str)) {
this.add_error({
col,
length: arg_str.length,
message: `Expected string.`,
});
} else {
const value = JSON.parse(arg_str);
args.push({
value,
size: 2 + 2 * value.length,
});
}
}
private parse_uint_varargs(
arg_tokens: ArgToken[],
index: number,
size: number,
args: Arg[]
): void {
for (; index < arg_tokens.length; index++) {
const arg_token = arg_tokens[index];
const col = arg_token.col;
this.parse_uint(arg_token.arg, size, args, col);
}
}
}
function parse_uint(
arg_str: string,
size: number,
args: Arg[],
line: number,
col: number,
errors: AssemblyError[]
): void {
const bit_size = 8 * size;
const value = parseInt(arg_str, 10);
const max_value = Math.pow(2, bit_size) - 1;
if (!/^\d+$/.test(arg_str)) {
errors.push({
line_no: line,
col,
length: arg_str.length,
message: `Expected unsigned integer.`,
});
} else if (value > max_value) {
errors.push({
line_no: line,
col,
length: arg_str.length,
message: `${bit_size}-Bit unsigned integer can't be greater than ${max_value}.`,
});
} else {
args.push({
value,
size,
});
}
}
function parse_sint(
arg_str: string,
size: number,
args: Arg[],
line: number,
col: number,
errors: AssemblyError[]
): void {
const bit_size = 8 * size;
const value = parseInt(arg_str, 10);
const min_value = -Math.pow(2, bit_size - 1);
const max_value = Math.pow(2, bit_size - 1) - 1;
if (!/^-?\d+$/.test(arg_str)) {
errors.push({
line_no: line,
col,
length: arg_str.length,
message: `Expected signed integer.`,
});
} else if (value < min_value) {
errors.push({
line_no: line,
col,
length: arg_str.length,
message: `${bit_size}-Bit signed integer can't be less than ${min_value}.`,
});
} else if (value > max_value) {
errors.push({
line_no: line,
col,
length: arg_str.length,
message: `${bit_size}-Bit signed integer can't be greater than ${max_value}.`,
});
} else {
args.push({
value,
size,
});
}
}
function parse_float(
arg_str: string,
args: Arg[],
line: number,
col: number,
errors: AssemblyError[]
): void {
const value = parseFloat(arg_str);
if (!Number.isFinite(value)) {
errors.push({
line_no: line,
col,
length: arg_str.length,
message: `Expected floating point number.`,
});
} else {
args.push({
value,
size: 4,
});
}
}
function parse_register(
arg_str: string,
args: Arg[],
line: number,
col: number,
errors: AssemblyError[]
): void {
const value = parseInt(arg_str.slice(1), 10);
if (!/^r\d+$/.test(arg_str)) {
errors.push({
line_no: line,
col,
length: arg_str.length,
message: `Expected register reference.`,
});
} else if (value > 255) {
errors.push({
line_no: line,
col,
length: arg_str.length,
message: `Invalid register reference, expected r0-r255.`,
});
} else {
args.push({
value,
size: 1,
});
}
}
function parse_string(
arg_str: string,
args: Arg[],
line: number,
col: number,
errors: AssemblyError[]
): void {
if (!/^"([^"\\]|\\.)*"$/.test(arg_str)) {
errors.push({
line_no: line,
col,
length: arg_str.length,
message: `Expected string.`,
});
} else {
const value = JSON.parse(arg_str);
args.push({
value,
size: 2 + 2 * value.length,
});
}
}
function parse_uint_varargs(
arg_tokens: ArgToken[],
index: number,
size: number,
args: Arg[],
line: number,
errors: AssemblyError[]
): void {
for (; index < arg_tokens.length; index++) {
const arg_token = arg_tokens[index];
const col = arg_token.col;
parse_uint(arg_token.arg, size, args, line, col, errors);
}
}

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";
const ctx: Worker = self as any;
@ -65,8 +65,8 @@ function process_messages(): void {
}
}
const response: NewErrorsOutput = {
type: "new_errors_output",
const response: NewObjectCodeOutput = {
type: "new_object_code_output",
...assemble(lines),
};
ctx.postMessage(response);

65
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(
instructions: Instruction[],
labels: Map<number, number>,
manual_stack: boolean = false
): string[] {
export function disassemble(object_code: Segment[], manual_stack: boolean = false): string[] {
const lines: string[] = [];
const index_to_label = new Map([...labels.entries()].map(([l, i]) => [i, l]));
const stack: Arg[] = [];
for (let i = 0; i < instructions.length; ++i) {
const ins = instructions[i];
const label = index_to_label.get(i);
for (const segment of object_code) {
if (segment.type === SegmentType.Data) {
continue;
}
if (!manual_stack && ins.opcode.push_stack) {
stack.push(...ins.args);
} else {
let args = args_to_strings(ins.opcode.params, ins.args);
if (segment.label !== -1) {
lines.push(`${segment.label}:`);
}
if (!manual_stack) {
args.push(
...args_to_strings(
ins.opcode.stack_params,
stack.splice(
Math.max(0, stack.length - ins.opcode.stack_params.length),
ins.opcode.stack_params.length
for (const instruction of segment.instructions) {
if (!manual_stack && instruction.opcode.push_stack) {
stack.push(...instruction.args);
} else {
let args = args_to_strings(instruction.opcode.params, instruction.args);
if (!manual_stack) {
args.push(
...args_to_strings(
instruction.opcode.stack_params,
stack.splice(
Math.max(0, stack.length - instruction.opcode.stack_params.length),
instruction.opcode.stack_params.length
)
)
)
);
}
lines.push(
" " +
instruction.opcode.mnemonic +
(args.length ? " " + args.join(", ") : "")
);
}
if (label != null) {
lines.push(`${label}:`);
}
lines.push(" " + ins.opcode.mnemonic + (args.length ? " " + args.join(", ") : ""));
}
}
// Ensure newline.
// Ensure newline at the end.
if (lines.length) {
lines.push("");
}
@ -64,7 +65,7 @@ function args_to_strings(params: Param[], args: Arg[]): string[] {
switch (type) {
case Type.U8Var:
case Type.U16Var:
case Type.ILabelVar:
for (; i < args.length; i++) {
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 { AutoSizer } from "react-virtualized";
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 { Action } from "../../undo";
import styles from "./AssemblyEditorComponent.css";
@ -130,7 +130,7 @@ type MonacoProps = {
class MonacoComponent extends Component<MonacoProps> {
private div_ref = createRef<HTMLDivElement>();
private editor?: editor.IStandaloneCodeEditor;
private assembler?: Assembler;
private assembler?: AssemblyAnalyser;
private disposers: (() => void)[] = [];
render(): ReactNode {
@ -149,7 +149,7 @@ class MonacoComponent extends Component<MonacoProps> {
wrappingIndent: "indent",
});
this.assembler = new Assembler();
this.assembler = new AssemblyAnalyser();
this.disposers.push(
this.dispose,
@ -182,7 +182,7 @@ class MonacoComponent extends Component<MonacoProps> {
const quest = quest_editor_store.current_quest;
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");
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.