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

Fixed most issues resulting from opcode typing changes.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2019-08-04 19:50:02 +02:00
parent 7aefdb688c
commit 8e5472044b
12 changed files with 592 additions and 530 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
assets_generation/resources/scripting/opcodes.yml
View File

@ -3687,9 +3687,9 @@ opcodes:
- code: 0xf955
mnemonic: bb_exchange_pd_item
params: # TODO: determine types
- type: any
- type: any
- type: any
- type: dword
- type: dword
- type: dword
- type: instruction_label
- type: instruction_label
stack: pop
@ -3697,11 +3697,11 @@ opcodes:
- code: 0xf956
mnemonic: bb_exchange_pd_srank
params: # TODO: determine types
- type: any
- type: any
- type: any
- type: any
- type: any
- type: dword
- type: dword
- type: dword
- type: dword
- type: dword
- type: instruction_label
- type: instruction_label
stack: pop
@ -3709,11 +3709,11 @@ opcodes:
- code: 0xf957
mnemonic: bb_exchange_pd_special
params: # TODO: determine types
- type: any
- type: any
- type: any
- type: any
- type: any
- type: dword
- type: dword
- type: dword
- type: dword
- type: dword
- type: dword
- type: instruction_label
- type: instruction_label
@ -3722,11 +3722,11 @@ opcodes:
- code: 0xf958
mnemonic: bb_exchange_pd_percent
params: # TODO: determine types
- type: any
- type: any
- type: any
- type: any
- type: any
- type: dword
- type: dword
- type: dword
- type: dword
- type: dword
- type: dword
- type: instruction_label
- type: instruction_label

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

@ -1,13 +1,37 @@
import Logger from "js-logger";
import { Endianness } from "../..";
import {
Arg,
DataSegment,
Instruction,
InstructionSegment,
Segment,
SegmentType,
} from "../../../scripting/instructions";
import {
Opcode,
OPCODES,
RegTupRefType,
StackInteraction,
TYPE_BYTE,
TYPE_DWORD,
TYPE_D_LABEL,
TYPE_FLOAT,
TYPE_I_LABEL,
TYPE_I_LABEL_VAR,
TYPE_LABEL,
TYPE_REF,
TYPE_REG_REF,
TYPE_REG_REF_VAR,
TYPE_STRING,
TYPE_S_LABEL,
TYPE_WORD,
} from "../../../scripting/opcodes";
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 "../../../scripting/opcodes";
export * from "../../../scripting/opcodes";
const logger = Logger.get("data_formats/parsing/quest/bin");
@ -23,89 +47,10 @@ export class BinFile {
) {}
}
/**
* Instruction invocation.
*/
export class Instruction {
/**
* Byte size of the argument list.
*/
readonly arg_size: number = 0;
/**
* Byte size of the entire instruction, i.e. the sum of the opcode size and all argument sizes.
*/
readonly size: number;
/**
* Maps each parameter by index to its arguments.
*/
readonly param_to_args: Arg[][] = [];
constructor(readonly opcode: Opcode, readonly args: Arg[]) {
for (let i = 0; i < opcode.params.length; i++) {
const type = opcode.params[i].type;
const arg = args[i];
this.param_to_args[i] = [];
if (arg == undefined) {
break;
}
switch (type) {
case Type.U8Var:
case Type.ILabelVar:
this.arg_size++;
for (let j = i; j < args.length; j++) {
this.param_to_args[i].push(args[j]);
this.arg_size += args[j].size;
}
break;
default:
this.arg_size += arg.size;
this.param_to_args[i].push(arg);
break;
}
}
this.size = opcode.size + this.arg_size;
}
}
export enum SegmentType {
Instructions,
Data,
}
const SEGMENT_PRIORITY: number[] = [];
SEGMENT_PRIORITY[SegmentType.Instructions] = 1;
SEGMENT_PRIORITY[SegmentType.Data] = 0;
/**
* Segment of object code.
*/
export type Segment = InstructionSegment | DataSegment;
export type InstructionSegment = {
type: SegmentType.Instructions;
labels: number[];
instructions: Instruction[];
};
export type DataSegment = {
type: SegmentType.Data;
labels: number[];
data: ArrayBuffer;
};
/**
* Instruction argument.
*/
export type Arg = {
value: any;
size: number;
};
export function parse_bin(
cursor: Cursor,
entry_labels: number[] = [0],
@ -509,10 +454,14 @@ function parse_instructions_segment(
const stack: Arg[] = [];
for (const instruction of instructions) {
const params = instruction.opcode.params;
const args = instruction.args;
const opcode = instruction.opcode;
const params = opcode.params;
const args =
opcode.stack === StackInteraction.Pop
? stack.splice(stack.length - params.length, params.length)
: instruction.args;
if (instruction.opcode.push_stack) {
if (opcode.stack === StackInteraction.Push) {
for (const arg of args) {
stack.push(arg);
}
@ -523,16 +472,23 @@ function parse_instructions_segment(
let segment_type: SegmentType;
switch (param_type) {
case Type.ILabel:
case TYPE_I_LABEL:
segment_type = SegmentType.Instructions;
break;
case Type.DLabel:
case TYPE_D_LABEL:
segment_type = SegmentType.Data;
case TYPE_S_LABEL:
segment_type = SegmentType.String;
break;
default:
continue;
}
if (!Number.isInteger(label)) {
logger.error(`Expected label reference but got ${label}.`);
continue;
}
parse_segment(
offset_to_segment,
label_holder,
@ -543,40 +499,13 @@ function parse_instructions_segment(
);
}
}
const stack_params = instruction.opcode.stack_params;
const stack_args = stack.splice(stack.length - stack_params.length, stack_params.length);
for (let i = 0; i < stack_args.length; i++) {
const param_type = stack_params[i].type;
let label = stack_args[i].value;
let segment_type: SegmentType;
switch (param_type) {
case Type.ILabel:
segment_type = SegmentType.Instructions;
break;
case Type.DLabel:
segment_type = SegmentType.Data;
break;
default:
continue;
}
if (!Number.isInteger(label)) {
logger.error(`Expected label reference but got ${label}.`);
continue;
}
parse_segment(offset_to_segment, label_holder, cursor, label, segment_type, lenient);
}
}
// Recurse on label drop-through.
if (
next_label != undefined &&
instructions.length &&
instructions[instructions.length - 1].opcode !== Opcode.ret
instructions[instructions.length - 1].opcode !== Opcode.RET
) {
parse_segment(
offset_to_segment,
@ -609,43 +538,25 @@ function parse_instruction_arguments(cursor: Cursor, opcode: Opcode): Arg[] {
for (const param of opcode.params) {
switch (param.type) {
case Type.U8:
case TYPE_BYTE:
args.push({ value: cursor.u8(), size: 1 });
break;
case Type.U16:
case TYPE_WORD:
args.push({ value: cursor.u16(), size: 2 });
break;
case Type.U32:
args.push({ value: cursor.u32(), size: 4 });
break;
case Type.I32:
case TYPE_DWORD:
args.push({ value: cursor.i32(), size: 4 });
break;
case Type.F32:
case TYPE_FLOAT:
args.push({ value: cursor.f32(), size: 4 });
break;
case Type.RegRef:
args.push({ value: cursor.u8(), size: 1 });
break;
case Type.ILabel:
case TYPE_LABEL:
case TYPE_I_LABEL:
case TYPE_D_LABEL:
case TYPE_S_LABEL:
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.ILabelVar:
{
const arg_size = cursor.u8();
args.push(...cursor.u16_array(arg_size).map(value => ({ value, size: 2 })));
}
break;
case Type.String:
case TYPE_STRING:
{
const start_pos = cursor.position;
args.push({
@ -654,10 +565,28 @@ function parse_instruction_arguments(cursor: Cursor, opcode: Opcode): Arg[] {
});
}
break;
case TYPE_I_LABEL_VAR:
{
const arg_size = cursor.u8();
args.push(...cursor.u16_array(arg_size).map(value => ({ value, size: 2 })));
}
break;
case TYPE_REG_REF:
args.push({ value: cursor.u8(), size: 1 });
break;
case TYPE_REG_REF_VAR:
{
const arg_size = cursor.u8();
args.push(...cursor.u8_array(arg_size).map(value => ({ value, size: 1 })));
}
break;
default:
throw new Error(
`Parameter type ${Type[param.type]} (${param.type}) not implemented.`
);
if (param.type instanceof RegTupRefType) {
args.push({ value: cursor.u8(), size: 1 });
break;
} else {
throw new Error(`Parameter type ${param.type} not implemented.`);
}
}
}
@ -693,47 +622,50 @@ function write_object_code(
const [arg] = args;
switch (param.type) {
case Type.U8:
case TYPE_BYTE:
cursor.write_u8(arg.value);
break;
case Type.U16:
case TYPE_WORD:
cursor.write_u16(arg.value);
break;
case Type.U32:
cursor.write_u32(arg.value);
case TYPE_DWORD:
if (arg.value >= 0) {
cursor.write_u32(arg.value);
} else {
cursor.write_i32(arg.value);
}
break;
case Type.I32:
cursor.write_i32(arg.value);
break;
case Type.F32:
case TYPE_FLOAT:
cursor.write_f32(arg.value);
break;
case Type.RegRef:
cursor.write_u8(arg.value);
break;
case Type.ILabel:
case TYPE_LABEL: // Abstract type
case TYPE_I_LABEL:
case TYPE_D_LABEL:
case TYPE_S_LABEL:
cursor.write_u16(arg.value);
break;
case Type.DLabel:
cursor.write_u16(arg.value);
case TYPE_STRING:
cursor.write_string_utf16(arg.value, arg.size);
break;
case Type.U8Var:
cursor.write_u8(args.length);
cursor.write_u8_array(args.map(arg => arg.value));
break;
case Type.ILabelVar:
case TYPE_I_LABEL_VAR:
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);
case TYPE_REF: // Abstract type
case TYPE_REG_REF:
cursor.write_u8(arg.value);
break;
case TYPE_REG_REF_VAR:
cursor.write_u8(args.length);
cursor.write_u8_array(args.map(arg => arg.value));
break;
default:
throw new Error(
`Parameter type ${Type[param.type]} (${
param.type
}) not implemented.`
);
if (param.type instanceof RegTupRefType) {
cursor.write_u8(arg.value);
} else {
// TYPE_ANY and TYPE_POINTER cannot be serialized.
throw new Error(`Parameter type ${param.type} not implemented.`);
}
}
}
}

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

@ -1,5 +1,6 @@
import { InstructionSegment, Opcode, SegmentType } from "../data_formats/parsing/quest/bin";
import { assemble } from "./assembly";
import { InstructionSegment, SegmentType } from "./instructions";
import { Opcode } from "./opcodes";
test("", () => {
const { object_code, warnings, errors } = assemble(
@ -25,10 +26,10 @@ test("", () => {
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].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].opcode).toBe(Opcode.BB_MAP_DESIGNATE);
expect(segment_0.instructions[1].args).toEqual([
{ value: 1, size: 1 },
{ value: 2, size: 2 },
@ -36,21 +37,21 @@ test("", () => {
{ value: 4, size: 1 },
]);
expect(segment_0.instructions[2].opcode).toBe(Opcode.arg_pushl);
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].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].opcode).toBe(Opcode.SET_FLOOR_HANDLER);
expect(segment_0.instructions[4].args).toEqual([]);
expect(segment_0.instructions[5].opcode).toBe(Opcode.arg_pushl);
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].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].opcode).toBe(Opcode.SET_FLOOR_HANDLER);
expect(segment_0.instructions[7].args).toEqual([]);
expect(segment_0.instructions[8].opcode).toBe(Opcode.ret);
expect(segment_0.instructions[8].opcode).toBe(Opcode.RET);
expect(segment_0.instructions[8].args).toEqual([]);
const segment_1 = object_code[1] as InstructionSegment;
@ -58,12 +59,12 @@ test("", () => {
expect(segment_1.type).toBe(SegmentType.Instructions);
expect(segment_1.instructions.length).toBe(3);
expect(segment_1.instructions[0].opcode).toBe(Opcode.arg_pushl);
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].opcode).toBe(Opcode.SET_MAINWARP);
expect(segment_1.instructions[1].args).toEqual([]);
expect(segment_1.instructions[2].opcode).toBe(Opcode.ret);
expect(segment_1.instructions[2].opcode).toBe(Opcode.RET);
expect(segment_1.instructions[2].args).toEqual([]);
const segment_2 = object_code[2] as InstructionSegment;
@ -71,6 +72,6 @@ test("", () => {
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].opcode).toBe(Opcode.RET);
expect(segment_2.instructions[0].args).toEqual([]);
});

21
src/scripting/assembly.ts
View File

@ -1,16 +1,4 @@
import Logger from "js-logger";
import {
Arg,
Instruction,
InstructionSegment,
Opcode,
OPCODES_BY_MNEMONIC,
Param,
Segment,
SegmentType,
Type,
DataSegment,
} from "../data_formats/parsing/quest/bin";
import {
AssemblyLexer,
CodeSectionToken,
@ -22,6 +10,15 @@ import {
Token,
TokenType,
} from "./AssemblyLexer";
import {
Segment,
Arg,
InstructionSegment,
SegmentType,
Instruction,
DataSegment,
} from "./instructions";
import { Opcode, OPCODES_BY_MNEMONIC, Param } from "./opcodes";
const logger = Logger.get("scripting/assembly");

2
src/scripting/data_flow_analysis/ControlFlowGraph.test.ts
View File

@ -1,5 +1,5 @@
import { InstructionSegment, SegmentType } from "../../data_formats/parsing/quest/bin";
import { assemble } from "../assembly";
import { InstructionSegment, SegmentType } from "../instructions";
import { BranchType, ControlFlowGraph } from "./ControlFlowGraph";
test("single instruction", () => {

101
src/scripting/data_flow_analysis/ControlFlowGraph.ts
View File

@ -1,10 +1,5 @@
import {
Instruction,
InstructionSegment,
Opcode,
Segment,
SegmentType,
} from "../../data_formats/parsing/quest/bin";
import { Instruction, InstructionSegment, Segment, SegmentType } from "../instructions";
import { Opcode } from "../opcodes";
export enum BranchType {
None,
@ -74,61 +69,61 @@ export class ControlFlowGraph {
switch (inst.opcode) {
// Return.
case Opcode.ret:
case Opcode.RET:
branch_type = BranchType.Return;
branch_labels = [];
break;
// Unconditional jump.
case Opcode.jmp:
case Opcode.JMP:
branch_type = BranchType.Jump;
branch_labels = [inst.args[0].value];
break;
// Conditional jumps.
case Opcode.jmp_on:
case Opcode.jmp_off:
case Opcode.JMP_ON:
case Opcode.JMP_OFF:
branch_type = BranchType.ConditionalJump;
branch_labels = [inst.args[0].value];
break;
case Opcode.jmp_e:
case Opcode.jmpi_e:
case Opcode.jmp_ne:
case Opcode.jmpi_ne:
case Opcode.ujmp_g:
case Opcode.ujmpi_g:
case Opcode.jmp_g:
case Opcode.jmpi_g:
case Opcode.ujmp_l:
case Opcode.ujmpi_l:
case Opcode.jmp_l:
case Opcode.jmpi_l:
case Opcode.ujmp_ge:
case Opcode.ujmpi_ge:
case Opcode.jmp_ge:
case Opcode.jmpi_ge:
case Opcode.ujmp_le:
case Opcode.ujmpi_le:
case Opcode.jmp_le:
case Opcode.jmpi_le:
case Opcode.JMP_E:
case Opcode.JMPI_E:
case Opcode.JMP_NE:
case Opcode.JMPI_NE:
case Opcode.UJMP_G:
case Opcode.UJMPI_G:
case Opcode.JMP_G:
case Opcode.JMPI_G:
case Opcode.UJMP_L:
case Opcode.UJMPI_L:
case Opcode.JMP_L:
case Opcode.JMPI_L:
case Opcode.UJMP_GE:
case Opcode.UJMPI_GE:
case Opcode.JMP_GE:
case Opcode.JMPI_GE:
case Opcode.UJMP_LE:
case Opcode.UJMPI_LE:
case Opcode.JMP_LE:
case Opcode.JMPI_LE:
branch_type = BranchType.ConditionalJump;
branch_labels = [inst.args[2].value];
break;
case Opcode.switch_jmp:
case Opcode.SWITCH_JMP:
branch_type = BranchType.ConditionalJump;
branch_labels = inst.args.slice(1).map(a => a.value);
break;
// Calls.
case Opcode.call:
case Opcode.CALL:
branch_type = BranchType.Call;
branch_labels = [inst.args[0].value];
break;
case Opcode.va_call:
case Opcode.VA_CALL:
branch_type = BranchType.Call;
branch_labels = [inst.args[0].value];
break;
case Opcode.switch_call:
case Opcode.SWITCH_CALL:
branch_type = BranchType.Call;
branch_labels = inst.args.slice(1).map(a => a.value);
break;
@ -281,46 +276,46 @@ function data_flow(
for (const state of out_states) {
switch (instruction.opcode) {
case Opcode.let:
case Opcode.flet:
case Opcode.LET:
case Opcode.FLET:
state.set(
args[0].value,
state.get_min(args[1].value),
state.get_max(args[1].value)
);
break;
case Opcode.leti:
case Opcode.letb:
case Opcode.letw:
case Opcode.leta:
case Opcode.sync_leti:
case Opcode.sync_register:
case Opcode.LETI:
case Opcode.LETB:
case Opcode.LETW:
case Opcode.LETA:
case Opcode.SYNC_LETI:
case Opcode.SYNC_REGISTER:
state.set(args[0].value, args[1].value, args[1].value);
break;
case Opcode.leto:
case Opcode.LETO:
{
const info = label_holder.get_info(args[1].value);
state.set(args[0].value, info ? info.offset : 0, info ? info.offset : 0);
}
break;
case Opcode.set:
case Opcode.SET:
state.set(args[0].value, 1, 1);
break;
case Opcode.clear:
case Opcode.CLEAR:
state.set(args[0].value, 0, 0);
break;
case Opcode.leti:
case Opcode.letb:
case Opcode.letw:
case Opcode.leta:
case Opcode.sync_leti:
case Opcode.sync_register:
case Opcode.LETI:
case Opcode.LETB:
case Opcode.LETW:
case Opcode.LETA:
case Opcode.SYNC_LETI:
case Opcode.SYNC_REGISTER:
state.set(args[0].value, args[1].value, args[1].value);
break;
// case Opcode.fleti:
// state.setf(args[0].value, args[1].value);
// break;
case Opcode.rev:
case Opcode.REV:
{
const reg = args[0].value;
const max = state.get_min(reg) <= 0 && state.get_max(reg) >= 0 ? 1 : 0;

11
src/scripting/data_flow_analysis/register_values.test.ts
View File

@ -1,5 +1,6 @@
import { InstructionSegment, Opcode, SegmentType } from "../../data_formats/parsing/quest/bin";
import { assemble } from "../assembly";
import { InstructionSegment, SegmentType } from "../instructions";
import { Opcode } from "../opcodes";
import { ControlFlowGraph } from "./ControlFlowGraph";
import {
MAX_REGISTER_VALUE,
@ -140,10 +141,10 @@ function test_branched(opcode: Opcode, ...expected: number[]): void {
});
}
test_branched(Opcode.addi, 25, 35);
test_branched(Opcode.subi, -5, 5);
test_branched(Opcode.muli, 150, 300);
test_branched(Opcode.divi, 0, 1);
test_branched(Opcode.ADDI, 25, 35);
test_branched(Opcode.SUBI, -5, 5);
test_branched(Opcode.MULI, 150, 300);
test_branched(Opcode.DIVI, 0, 1);
test(`${register_values.name} get_random`, () => {
const im = to_instructions(`

82
src/scripting/data_flow_analysis/register_values.ts
View File

@ -1,10 +1,5 @@
import {
Instruction,
Opcode,
RegTupRefType,
TYPE_REG_REF,
TYPE_REG_REF_VAR,
} from "../../data_formats/parsing/quest/bin";
import { Instruction } from "../instructions";
import { Opcode, ParamAccess, RegTupRefType } from "../opcodes";
import { BasicBlock, ControlFlowGraph } from "./ControlFlowGraph";
import { ValueSet } from "./ValueSet";
@ -52,30 +47,30 @@ function find_values(
const args = instruction.args;
switch (instruction.opcode) {
case Opcode.let:
case Opcode.LET:
if (args[0].value === register) {
values = find_values(new Set(path), block, i, args[1].value);
}
break;
case Opcode.leti:
case Opcode.letb:
case Opcode.letw:
case Opcode.sync_leti:
case Opcode.LETI:
case Opcode.LETB:
case Opcode.LETW:
case Opcode.SYNC_LETI:
if (args[0].value === register) {
values.set_value(args[1].value);
}
break;
case Opcode.set:
case Opcode.SET:
if (args[0].value === register) {
values.set_value(1);
}
break;
case Opcode.clear:
case Opcode.CLEAR:
if (args[0].value === register) {
values.set_value(0);
}
break;
case Opcode.rev:
case Opcode.REV:
if (args[0].value === register) {
const prev_vals = find_values(new Set(path), block, i, register);
const prev_size = prev_vals.size();
@ -89,42 +84,42 @@ function find_values(
}
}
break;
case Opcode.addi:
case Opcode.ADDI:
if (args[0].value === register) {
values = find_values(new Set(path), block, i, register);
values.scalar_add(args[1].value);
}
break;
case Opcode.subi:
case Opcode.SUBI:
if (args[0].value === register) {
values = find_values(new Set(path), block, i, register);
values.scalar_sub(args[1].value);
}
break;
case Opcode.muli:
case Opcode.MULI:
if (args[0].value === register) {
values = find_values(new Set(path), block, i, register);
values.scalar_mul(args[1].value);
}
break;
case Opcode.divi:
case Opcode.DIVI:
if (args[0].value === register) {
values = find_values(new Set(path), block, i, register);
values.scalar_div(args[1].value);
}
break;
case Opcode.if_zone_clear:
case Opcode.IF_ZONE_CLEAR:
if (args[0].value === register) {
values.set_interval(0, 1);
}
break;
case Opcode.get_difflvl:
case Opcode.get_slotnumber:
case Opcode.GET_DIFFLVL:
case Opcode.GET_SLOTNUMBER:
if (args[0].value === register) {
values.set_interval(0, 3);
}
break;
case Opcode.get_random:
case Opcode.GET_RANDOM:
if (args[1].value === register) {
// TODO: undefined values.
const min = find_values(new Set(path), block, i, args[0].value).min() || 0;
@ -135,26 +130,41 @@ function find_values(
values.set_interval(min, max - 1);
}
break;
case Opcode.STACK_PUSHM:
case Opcode.STACK_POPM:
{
const min_reg = args[0].value;
const max_reg = args[0].value + args[1].value;
if (min_reg <= register && register < max_reg) {
values.set_interval(MIN_REGISTER_VALUE, MAX_REGISTER_VALUE);
}
}
break;
default:
// Assume any other opcodes that write to the register can produce any value.
{
const params = instruction.opcode.params;
const len = Math.min(args.length, params.length);
const arg_len = Math.min(args.length, params.length);
for (let j = 0; j < len; j++) {
outer: for (let j = 0; j < arg_len; j++) {
const param = params[j];
const val = args[j].value;
if (param.write) {
if (
(param.type instanceof RegTupRefType &&
register >= val &&
register < val + param.type.registers.length) ||
(param.type === TYPE_REG_REF && val.includes(register)) ||
(param.type === TYPE_REG_REF_VAR && val.includes(register))
) {
values.set_interval(MIN_REGISTER_VALUE, MAX_REGISTER_VALUE);
break;
if (param.type instanceof RegTupRefType) {
const reg_ref = args[j].value;
let k = 0;
for (const reg_param of param.type.registers) {
if (
(reg_param.access === ParamAccess.Write ||
reg_param.access === ParamAccess.ReadWrite) &&
reg_ref + k === register
) {
values.set_interval(MIN_REGISTER_VALUE, MAX_REGISTER_VALUE);
break outer;
}
k++;
}
}
}

57
src/scripting/disassembly.ts
View File

@ -1,4 +1,13 @@
import { Arg, Param, Segment, SegmentType, Type } from "../data_formats/parsing/quest/bin";
import { Arg, Segment, SegmentType } from "./instructions";
import {
Param,
StackInteraction,
TYPE_STRING,
TYPE_I_LABEL_VAR,
TYPE_REG_REF_VAR,
TYPE_REG_REF,
RegTupRefType,
} from "./opcodes";
/**
* @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.
@ -53,26 +62,27 @@ export function disassemble(object_code: Segment[], manual_stack: boolean = fals
if (line.length > 4) {
lines.push(line);
}
} else if (segment.type === SegmentType.String) {
lines.push(" " + segment.value);
} else {
for (const instruction of segment.instructions) {
if (!manual_stack && instruction.opcode.push_stack) {
if (!manual_stack && instruction.opcode.stack === StackInteraction.Push) {
stack.push(...instruction.args);
} else {
let args = args_to_strings(instruction.opcode.params, instruction.args);
let args: string[] = [];
if (!manual_stack) {
args.push(
...args_to_strings(
instruction.opcode.stack_params,
if (instruction.opcode.stack === StackInteraction.Pop) {
if (!manual_stack) {
args = args_to_strings(
instruction.opcode.params,
stack.splice(
Math.max(
0,
stack.length - instruction.opcode.stack_params.length
),
instruction.opcode.stack_params.length
Math.max(0, stack.length - instruction.opcode.params.length),
instruction.opcode.params.length
)
)
);
);
}
} else {
args = args_to_strings(instruction.opcode.params, instruction.args);
}
lines.push(
@ -106,21 +116,28 @@ function args_to_strings(params: Param[], args: Arg[]): string[] {
}
switch (type) {
case Type.U8Var:
case Type.ILabelVar:
case TYPE_I_LABEL_VAR:
for (; i < args.length; i++) {
arg_strings.push(args[i].value.toString());
}
break;
case Type.RegRef:
case TYPE_REG_REF_VAR:
for (; i < args.length; i++) {
arg_strings.push("r" + args[i].value);
}
break;
case TYPE_REG_REF:
arg_strings.push("r" + arg.value);
break;
case Type.String:
case TYPE_STRING:
arg_strings.push(JSON.stringify(arg.value));
break;
default:
arg_strings.push(arg.value.toString());
if (type instanceof RegTupRefType) {
arg_strings.push("r" + arg.value);
} else {
arg_strings.push(arg.value.toString());
}
break;
}
}

87
src/scripting/instructions.ts Normal file
View File

@ -0,0 +1,87 @@
import { TYPE_I_LABEL_VAR, TYPE_REG_REF_VAR, Opcode } from "./opcodes";
/**
* Instruction invocation.
*/
export class Instruction {
/**
* Byte size of the argument list.
*/
readonly arg_size: number = 0;
/**
* Byte size of the entire instruction, i.e. the sum of the opcode size and all argument sizes.
*/
readonly size: number;
/**
* Maps each parameter by index to its arguments.
*/
readonly param_to_args: Arg[][] = [];
constructor(readonly opcode: Opcode, readonly args: Arg[]) {
for (let i = 0; i < opcode.params.length; i++) {
const type = opcode.params[i].type;
const arg = args[i];
this.param_to_args[i] = [];
if (arg == undefined) {
break;
}
switch (type) {
case TYPE_I_LABEL_VAR:
case TYPE_REG_REF_VAR:
this.arg_size++;
for (let j = i; j < args.length; j++) {
this.param_to_args[i].push(args[j]);
this.arg_size += args[j].size;
}
break;
default:
this.arg_size += arg.size;
this.param_to_args[i].push(arg);
break;
}
}
this.size = opcode.size + this.arg_size;
}
}
/**
* Instruction argument.
*/
export type Arg = {
value: any;
size: number;
};
export enum SegmentType {
Instructions,
Data,
String,
}
/**
* Segment of object code.
*/
export type Segment = InstructionSegment | DataSegment | StringSegment;
export type InstructionSegment = {
type: SegmentType.Instructions;
labels: number[];
instructions: Instruction[];
};
export type DataSegment = {
type: SegmentType.Data;
labels: number[];
data: ArrayBuffer;
};
export type StringSegment = {
type: SegmentType.String;
labels: number[];
value: string;
};

349
src/scripting/opcodes.ts
View File

File diff suppressed because it is too large Load Diff

73
src/stores/quest_creation.ts
View File

@ -1,7 +1,8 @@
import { Instruction, Opcode, SegmentType } from "../data_formats/parsing/quest/bin";
import { Vec3 } from "../data_formats/vector";
import { Episode, NpcType, ObjectType, Quest, QuestNpc, QuestObject } from "../domain";
import { area_store } from "./AreaStore";
import { SegmentType, Instruction } from "../scripting/instructions";
import { Opcode } from "../scripting/opcodes";
export function create_new_quest(episode: Episode): Quest {
if (episode === Episode.II) throw new Error("Episode II not yet supported.");
@ -22,52 +23,52 @@ export function create_new_quest(episode: Episode): Quest {
labels: [0],
type: SegmentType.Instructions,
instructions: [
new Instruction(Opcode.set_episode, [{ value: 0, size: 4 }]),
new Instruction(Opcode.arg_pushl, [{ value: 0, size: 4 }]),
new Instruction(Opcode.arg_pushw, [{ value: 150, size: 2 }]),
new Instruction(Opcode.set_floor_handler, []),
new Instruction(Opcode.bb_map_designate, [
new Instruction(Opcode.SET_EPISODE, [{ value: 0, size: 4 }]),
new Instruction(Opcode.ARG_PUSHL, [{ value: 0, size: 4 }]),
new Instruction(Opcode.ARG_PUSHW, [{ value: 150, size: 2 }]),
new Instruction(Opcode.SET_FLOOR_HANDLER, []),
new Instruction(Opcode.BB_MAP_DESIGNATE, [
{ value: 0, size: 1 },
{ value: 0, size: 2 },
{ value: 0, size: 1 },
{ value: 0, size: 1 },
]),
new Instruction(Opcode.ret, []),
new Instruction(Opcode.RET, []),
],
},
{
labels: [150],
type: SegmentType.Instructions,
instructions: [
new Instruction(Opcode.leti, [{ value: 60, size: 1 }, { value: 237, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 61, size: 1 }, { value: 0, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 62, size: 1 }, { value: 333, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 63, size: 1 }, { value: -15, size: 4 }]),
new Instruction(Opcode.arg_pushl, [{ value: 0, size: 4 }]),
new Instruction(Opcode.arg_pushr, [{ value: 60, size: 1 }]),
new Instruction(Opcode.p_setpos, []),
new Instruction(Opcode.leti, [{ value: 60, size: 1 }, { value: 255, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 61, size: 1 }, { value: 0, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 62, size: 1 }, { value: 338, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 63, size: 1 }, { value: -43, size: 4 }]),
new Instruction(Opcode.arg_pushl, [{ value: 1, size: 4 }]),
new Instruction(Opcode.arg_pushr, [{ value: 60, size: 1 }]),
new Instruction(Opcode.p_setpos, []),
new Instruction(Opcode.leti, [{ value: 60, size: 1 }, { value: 222, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 61, size: 1 }, { value: 0, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 62, size: 1 }, { value: 322, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 63, size: 1 }, { value: 25, size: 4 }]),
new Instruction(Opcode.arg_pushl, [{ value: 2, size: 4 }]),
new Instruction(Opcode.arg_pushr, [{ value: 60, size: 1 }]),
new Instruction(Opcode.p_setpos, []),
new Instruction(Opcode.leti, [{ value: 60, size: 1 }, { value: 248, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 61, size: 1 }, { value: 0, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 62, size: 1 }, { value: 323, size: 4 }]),
new Instruction(Opcode.leti, [{ value: 63, size: 1 }, { value: -20, size: 4 }]),
new Instruction(Opcode.arg_pushl, [{ value: 3, size: 4 }]),
new Instruction(Opcode.arg_pushr, [{ value: 60, size: 1 }]),
new Instruction(Opcode.p_setpos, []),
new Instruction(Opcode.ret, []),
new Instruction(Opcode.LETI, [{ value: 60, size: 1 }, { value: 237, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 61, size: 1 }, { value: 0, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 62, size: 1 }, { value: 333, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 63, size: 1 }, { value: -15, size: 4 }]),
new Instruction(Opcode.ARG_PUSHL, [{ value: 0, size: 4 }]),
new Instruction(Opcode.ARG_PUSHR, [{ value: 60, size: 1 }]),
new Instruction(Opcode.P_SETPOS, []),
new Instruction(Opcode.LETI, [{ value: 60, size: 1 }, { value: 255, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 61, size: 1 }, { value: 0, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 62, size: 1 }, { value: 338, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 63, size: 1 }, { value: -43, size: 4 }]),
new Instruction(Opcode.ARG_PUSHL, [{ value: 1, size: 4 }]),
new Instruction(Opcode.ARG_PUSHR, [{ value: 60, size: 1 }]),
new Instruction(Opcode.P_SETPOS, []),
new Instruction(Opcode.LETI, [{ value: 60, size: 1 }, { value: 222, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 61, size: 1 }, { value: 0, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 62, size: 1 }, { value: 322, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 63, size: 1 }, { value: 25, size: 4 }]),
new Instruction(Opcode.ARG_PUSHL, [{ value: 2, size: 4 }]),
new Instruction(Opcode.ARG_PUSHR, [{ value: 60, size: 1 }]),
new Instruction(Opcode.P_SETPOS, []),
new Instruction(Opcode.LETI, [{ value: 60, size: 1 }, { value: 248, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 61, size: 1 }, { value: 0, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 62, size: 1 }, { value: 323, size: 4 }]),
new Instruction(Opcode.LETI, [{ value: 63, size: 1 }, { value: -20, size: 4 }]),
new Instruction(Opcode.ARG_PUSHL, [{ value: 3, size: 4 }]),
new Instruction(Opcode.ARG_PUSHR, [{ value: 60, size: 1 }]),
new Instruction(Opcode.P_SETPOS, []),
new Instruction(Opcode.RET, []),
],
},
],