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

src/data_formats/cursor/AbstractCursor.ts

@@ -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());
     }

src/data_formats/cursor/Cursor.ts

@@ -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.
      */

src/data_formats/parsing/quest/bin.test.ts

@@ -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", () => {
+function test_quest(path: string) {
-    const orig_buffer = readFileSync("test/resources/quest118_e.bin");
+    const orig_buffer = readFileSync(path);
     const orig_bin = prs_decompress(new BufferCursor(orig_buffer, Endianness.Little));
     const 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");
 });

src/data_formats/parsing/quest/bin.ts

@@ -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,
-        /**
+        readonly object_code: Segment[],
-         * Map of labels to instruction indices.
-         */
-        readonly labels: Map<number, number>,
-        readonly instructions: Instruction[],
         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) {
+    for (const segment of segments) {
-        instruction_size += instruction.size;
+        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) {
+    if (object_code.size !== segments_size) {
-        throw new Error(
+        const message = `Expected to parse ${object_code.size} bytes but parsed ${segments_size} instead.`;
-            `Expected to parse ${object_code.size} bytes but parsed ${instruction_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);
+    // Verify labels.
-    cursor.seek_start(label_offset_table_offset);
+    outer: for (let label = 0; label < label_offset_count; label++) {
-
+        if (label_offsets[label] !== -1) {
-    const labels = new Map<number, number>();
+            for (const segment of segments) {
-
+                if (segment.label === label) {
-    for (let label = 0; label < label_offset_count; ++label) {
+                    continue outer;
-        const offset = cursor.i32();
-
-        if (offset >= 0) {
-            let size = 0;
-            let index = 0;
-
-            for (const instruction of instructions) {
-                if (offset === size) {
-                    break;
-                } else if (offset < size) {
-                    logger.warn(
-                        `Label ${label} offset ${offset} does not point to the start of an instruction.`
-                    );
-                    break;
                 }
-
-                size += instruction.size;
-                index++;
             }
 
-            if (index >= instructions.length) {
+            logger.warn(
-                logger.warn(`Label ${label} offset ${offset} is too large.`);
+                `Label ${label} with offset ${label_offsets[label]} does not point to anything.`
-            } else {
+            );
-                labels.set(label, index);
-            }
         }
     }
 
@@ -179,22 +193,14 @@ export function parse_bin(cursor: Cursor, lenient: boolean = false): BinFile {
         quest_name,
         short_description,
         long_description,
-        labels,
+        segments,
-        instructions,
         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(
+    const buffer = new ResizableBuffer(object_code_offset + 100 * bin.object_code.length);
-        object_code_offset + 10 * bin.instructions.length + 4 * labels.length
-    );
     const cursor = new ResizableBufferCursor(buffer, Endianness.Little);
 
     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++) {
+    for (let label = 0; label < label_offsets.length; label++) {
-        const index = labels[label];
+        const offset = label_offsets[label];
 
-        if (index == null) {
+        if (offset == undefined) {
             cursor.write_i32(-1);
         } 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[] {
+function parse_object_code(
-    const instructions: Instruction[] = [];
+    cursor: Cursor,
+    offset_to_labels: Map<number, number[]>,
+    lenient: boolean
+): Segment[] {
+    const segments: Segment[] = [];
+    const data_labels = new Set<number>();
 
     try {
+        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(
+                if (lenient) {
-                    `Exception occurred while parsing arguments for instruction ${opcode.mnemonic}.`,
+                    logger.error(
-                    e
+                        `Exception occurred while parsing arguments for instruction ${opcode.mnemonic}.`,
-                );
+                        e
-                instructions.push(new Instruction(opcode, []));
+                    );
+                    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) {
+    // Write instructions first.
-        const opcode = instruction.opcode;
+    for (const segment of segments) {
-
+        if (segment.label !== -1) {
-        if (opcode.code_size === 2) {
+            label_offsets[segment.label] = cursor.position - start_pos;
-            cursor.write_u8(opcode.code >>> 8);
         }
 
-        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++) {
+                if (opcode.size === 2) {
-            const param = opcode.params[i];
+                    cursor.write_u8(opcode.code >>> 8);
-            const args = instruction.param_to_args[i];
+                }
-            const [arg] = args;
 
-            switch (param.type) {
+                cursor.write_u8(opcode.code & 0xff);
-                case Type.U8:
+
-                    cursor.write_u8(arg.value);
+                for (let i = 0; i < opcode.params.length; i++) {
-                    break;
+                    const param = opcode.params[i];
-                case Type.U16:
+                    const args = instruction.param_to_args[i];
-                    cursor.write_u16(arg.value);
+                    const [arg] = args;
-                    break;
+
-                case Type.U32:
+                    switch (param.type) {
-                    cursor.write_u32(arg.value);
+                        case Type.U8:
-                    break;
+                            cursor.write_u8(arg.value);
-                case Type.I32:
+                            break;
-                    cursor.write_i32(arg.value);
+                        case Type.U16:
-                    break;
+                            cursor.write_u16(arg.value);
-                case Type.F32:
+                            break;
-                    cursor.write_f32(arg.value);
+                        case Type.U32:
-                    break;
+                            cursor.write_u32(arg.value);
-                case Type.Register:
+                            break;
-                    cursor.write_u8(arg.value);
+                        case Type.I32:
-                    break;
+                            cursor.write_i32(arg.value);
-                case Type.U8Var:
+                            break;
-                    cursor.write_u8(args.length);
+                        case Type.F32:
-                    cursor.write_u8_array(args.map(arg => arg.value));
+                            cursor.write_f32(arg.value);
-                    break;
+                            break;
-                case Type.U16Var:
+                        case Type.Register:
-                    cursor.write_u8(args.length);
+                            cursor.write_u8(arg.value);
-                    cursor.write_u16_array(args.map(arg => arg.value));
+                            break;
-                    break;
+                        case Type.ILabel:
-                case Type.String:
+                            cursor.write_u16(arg.value);
-                    cursor.write_string_utf16(arg.value, arg.size);
+                            break;
-                    break;
+                        case Type.DLabel:
-                default:
+                            cursor.write_u16(arg.value);
-                    throw new Error(
+                            break;
-                        `Parameter type ${Type[param.type]} (${param.type}) not implemented.`
+                        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 };
 }

src/data_formats/parsing/quest/index.test.ts

@@ -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.object_code.length).toBe(orig_quest.object_code.length);
-        expect(test_quest.labels.size).toBe(orig_quest.labels.size);
+
+        for (let i = 0; i < orig_quest.object_code.length; i++) {
+            expect(test_quest.object_code[i].type).toBe(orig_quest.object_code[i].type);
+            expect(test_quest.object_code[i].label).toBe(orig_quest.object_code[i].label);
+        }
     });
 }
 

src/data_formats/parsing/quest/index.ts

@@ -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.object_code.length) {
-        if (bin.labels.has(0)) {
+        let label_0_segment: InstructionSegment | undefined;
-            const label_0_instructions = bin.get_label_instructions(0);
 
-            if (label_0_instructions) {
+        for (const segment of bin.object_code) {
-                episode = get_episode(label_0_instructions);
+            if (segment.type === SegmentType.Instructions && segment.label === 0) {
-                area_variants = get_area_variants(dat, episode, label_0_instructions, lenient);
+                label_0_segment = segment;
-            } else {
+                break;
-                logger.warn(`Index ${bin.labels.get(0)} for label 0 is invalid.`);
             }
+        }
+
+        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.object_code,
-        bin.instructions,
         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.object_code,
-            quest.instructions,
             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.");

src/data_formats/parsing/quest/opcodes.ts

@@ -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,

src/domain/index.ts

@@ -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 object_code: Segment[];
-    readonly instructions: Instruction[];
     readonly shop_items: number[];
 
     constructor(
@@ -167,8 +166,7 @@ export class Quest {
         objects: QuestObject[],
         npcs: QuestNpc[],
         dat_unknowns: DatUnknown[],
-        labels: Map<number, number>,
+        object_code: Segment[],
-        instructions: Instruction[],
         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 (!object_code) throw new Error("object_code is required.");
-        if (!instructions) throw new Error("instructions is required.");
         if (!shop_items) throw new Error("shop_items is required.");
 
         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.object_code = object_code;
-        this.instructions = instructions;
         this.shop_items = shop_items;
     }
 }

src/scripting/AssemblyAnalyser.ts

@@ -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 object_code: Segment[] = [];
-    private labels: Map<number, number> = new Map();
 
     constructor() {
         this.worker.onmessage = this.process_worker_message;
     }
 
-    disassemble(instructions: Instruction[], labels: Map<number, number>): string[] {
+    disassemble(object_code: Segment[]): string[] {
-        this.instructions = instructions;
+        this.object_code = object_code;
-        this.labels = labels;
+        const assembly = disassemble(object_code);
-        const assembly = disassemble(instructions, labels);
         const message: NewAssemblyInput = { type: "new_assembly_input", assembly };
         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") {
+        if (message.type === "new_object_code_output") {
-            this.instructions.splice(0, this.instructions.length, ...message.instructions);
+            this.object_code.splice(0, this.object_code.length, ...message.object_code);
-
-            this.labels.clear();
-
-            for (const [l, i] of message.labels) {
-                this.labels.set(l, i);
-            }
-
             this.errors = message.errors;
         }
     };

src/scripting/assembler_messages.ts

@@ -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 = {
+export type NewObjectCodeOutput = {
-    readonly type: "new_errors_output";
+    readonly type: "new_object_code_output";
-    readonly instructions: Instruction[];
+    readonly object_code: Segment[];
-    readonly labels: Map<number, number>;
     readonly errors: AssemblyError[];
 };

src/scripting/assembly.test.ts

@@ -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);
+    const segment_0 = object_code[0] as InstructionSegment;
-    expect(instructions[0].args).toEqual([{ value: 0, size: 4 }]);
 
-    expect(instructions[1].opcode).toBe(Opcode.bb_map_designate);
+    expect(segment_0.type).toBe(SegmentType.Instructions);
-    expect(instructions[1].args).toEqual([
+    expect(segment_0.instructions.length).toBe(9);
+
+    expect(segment_0.instructions[0].opcode).toBe(Opcode.set_episode);
+    expect(segment_0.instructions[0].args).toEqual([{ value: 0, size: 4 }]);
+
+    expect(segment_0.instructions[1].opcode).toBe(Opcode.bb_map_designate);
+    expect(segment_0.instructions[1].args).toEqual([
         { value: 1, size: 1 },
         { value: 2, size: 2 },
         { value: 3, size: 1 },
         { value: 4, size: 1 },
     ]);
 
-    expect(instructions[2].opcode).toBe(Opcode.arg_pushl);
+    expect(segment_0.instructions[2].opcode).toBe(Opcode.arg_pushl);
-    expect(instructions[2].args).toEqual([{ value: 0, size: 4 }]);
+    expect(segment_0.instructions[2].args).toEqual([{ value: 0, size: 4 }]);
-    expect(instructions[3].opcode).toBe(Opcode.arg_pushw);
+    expect(segment_0.instructions[3].opcode).toBe(Opcode.arg_pushw);
-    expect(instructions[3].args).toEqual([{ value: 150, size: 2 }]);
+    expect(segment_0.instructions[3].args).toEqual([{ value: 150, size: 2 }]);
-    expect(instructions[4].opcode).toBe(Opcode.set_floor_handler);
+    expect(segment_0.instructions[4].opcode).toBe(Opcode.set_floor_handler);
-    expect(instructions[4].args).toEqual([]);
+    expect(segment_0.instructions[4].args).toEqual([]);
 
-    expect(instructions[5].opcode).toBe(Opcode.arg_pushl);
+    expect(segment_0.instructions[5].opcode).toBe(Opcode.arg_pushl);
-    expect(instructions[5].args).toEqual([{ value: 1, size: 4 }]);
+    expect(segment_0.instructions[5].args).toEqual([{ value: 1, size: 4 }]);
-    expect(instructions[6].opcode).toBe(Opcode.arg_pushw);
+    expect(segment_0.instructions[6].opcode).toBe(Opcode.arg_pushw);
-    expect(instructions[6].args).toEqual([{ value: 151, size: 2 }]);
+    expect(segment_0.instructions[6].args).toEqual([{ value: 151, size: 2 }]);
-    expect(instructions[7].opcode).toBe(Opcode.set_floor_handler);
+    expect(segment_0.instructions[7].opcode).toBe(Opcode.set_floor_handler);
-    expect(instructions[7].args).toEqual([]);
+    expect(segment_0.instructions[7].args).toEqual([]);
 
-    expect(instructions[8].opcode).toBe(Opcode.ret);
+    expect(segment_0.instructions[8].opcode).toBe(Opcode.ret);
-    expect(instructions[8].args).toEqual([]);
+    expect(segment_0.instructions[8].args).toEqual([]);
 
-    expect(instructions[9].opcode).toBe(Opcode.arg_pushl);
+    const segment_1 = object_code[1] as InstructionSegment;
-    expect(instructions[9].args).toEqual([{ value: 1, size: 4 }]);
-    expect(instructions[10].opcode).toBe(Opcode.set_mainwarp);
-    expect(instructions[10].args).toEqual([]);
 
-    expect(instructions[11].opcode).toBe(Opcode.ret);
+    expect(segment_1.type).toBe(SegmentType.Instructions);
-    expect(instructions[11].args).toEqual([]);
+    expect(segment_1.instructions.length).toBe(3);
 
-    expect(instructions[12].opcode).toBe(Opcode.ret);
+    expect(segment_1.instructions[0].opcode).toBe(Opcode.arg_pushl);
-    expect(instructions[12].args).toEqual([]);
+    expect(segment_1.instructions[0].args).toEqual([{ value: 1, size: 4 }]);
+    expect(segment_1.instructions[1].opcode).toBe(Opcode.set_mainwarp);
+    expect(segment_1.instructions[1].args).toEqual([]);
 
-    expect(labels).toEqual(new Map([[0, 0], [150, 9], [151, 12]]));
+    expect(segment_1.instructions[2].opcode).toBe(Opcode.ret);
+    expect(segment_1.instructions[2].args).toEqual([]);
+
+    const segment_2 = object_code[2] as InstructionSegment;
+
+    expect(segment_2.type).toBe(SegmentType.Instructions);
+    expect(segment_2.instructions.length).toBe(1);
+
+    expect(segment_2.instructions[0].opcode).toBe(Opcode.ret);
+    expect(segment_2.instructions[0].args).toEqual([]);
 });

src/scripting/assembly.ts

@@ -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[];
+    object_code: Segment[];
-    labels: Map<number, number>;
     errors: AssemblyError[];
 } {
-    const errors: AssemblyError[] = [];
+    return new Assembler(assembly, manual_stack).assemble();
-    const instructions: Instruction[] = [];
-    const labels = new Map<number, number>();
-
-    let line_no = 1;
-
-    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,
-    };
 }
 
 type ArgToken = {
@@ -198,250 +32,410 @@ type ArgToken = {
     arg: string;
 };
 
-function tokenize_args(arg_str: string, col: number, args: ArgToken[]): boolean {
+class Assembler {
-    if (arg_str.trim().length === 0) {
+    private line_no!: number;
-        return true;
+    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) {
+        instructions.push(new Instruction(opcode, args));
-        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) {
+    private add_error({
-        return false;
+        col,
-    } else {
+        length,
-        const { arg_ws, arg } = match.groups;
+        message,
-        args.push({
+    }: {
-            col: col + arg_ws.length,
+        col: number;
-            arg,
+        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(
+    private parse_label(lbl: string, lbl_ws: string): void {
-    params: Param[],
+        const label = parseInt(lbl.slice(0, -1), 10);
-    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;
 
-        switch (param.type) {
+        if (!isFinite(label) || !/^\d+:$/.test(lbl)) {
-            case Type.U8:
+            this.add_error({
-                parse_uint(arg_str, 1, args, line, col, errors);
+                col: 1 + lbl_ws.length,
-                break;
+                length: lbl.length,
-            case Type.U16:
+                message: "Invalid label name.",
-                parse_uint(arg_str, 2, args, line, col, errors);
+            });
-                break;
+        } else {
-            case Type.U32:
+            if (this.labels.has(label)) {
-                parse_uint(arg_str, 4, args, line, col, errors);
+                this.add_error({
-                break;
+                    col: 1 + lbl_ws.length,
-            case Type.I32:
+                    length: lbl.length - 1,
-                parse_sint(arg_str, 4, args, line, col, errors);
+                    message: "Duplicate label.",
-                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.`,
                 });
+            }
+
+            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);
-    }
-}

src/scripting/assembly_worker.ts

@@ -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 = {
+    const response: NewObjectCodeOutput = {
-        type: "new_errors_output",
+        type: "new_object_code_output",
         ...assemble(lines),
     };
     ctx.postMessage(response);

src/scripting/disassembly.ts

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

src/ui/quest_editor/AssemblyEditorComponent.tsx

@@ -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(