Fixed bug that would disassemble arg_pushr arguments incorrectly in automatic stack management mode.

src/quest_editor/scripting/AssemblyAnalyser.ts

@@ -2,27 +2,27 @@ import { editor, languages } from "monaco-editor";
 import AssemblyWorker from "worker-loader!./assembly_worker";
 import {
     AssemblyChangeInput,
+    AssemblySettingsChangeInput,
     AssemblyWorkerOutput,
     InputMessageType,
     NewAssemblyInput,
     OutputMessageType,
     SignatureHelpInput,
-    AssemblySettingsChangeInput,
 } from "./assembly_worker_messages";
-import { AssemblyError, AssemblyWarning, AssemblySettings } from "./assembly";
+import { AssemblyError, AssemblySettings, AssemblyWarning } from "./assembly";
 import { disassemble } from "./disassembly";
 import { QuestModel } from "../model/QuestModel";
 import { Kind, OPCODES } from "./opcodes";
 import { Property } from "../../core/observable/property/Property";
 import { property } from "../../core/observable";
 import { WritableProperty } from "../../core/observable/property/WritableProperty";
+import { Disposable } from "../../core/observable/Disposable";
 import CompletionList = languages.CompletionList;
 import CompletionItemKind = languages.CompletionItemKind;
 import CompletionItem = languages.CompletionItem;
 import IModelContentChange = editor.IModelContentChange;
 import SignatureHelp = languages.SignatureHelp;
 import ParameterInformation = languages.ParameterInformation;
-import { Disposable } from "../../core/observable/Disposable";
 
 const INSTRUCTION_SUGGESTIONS = OPCODES.filter(opcode => opcode != null).map(opcode => {
     return ({
@@ -75,7 +75,7 @@ export class AssemblyAnalyser implements Disposable {
         this.worker.onmessage = this.process_worker_message;
     }
 
-    disassemble(quest: QuestModel, manual_stack?: boolean): string[] {
+    disassemble(quest: QuestModel, manual_stack: boolean): string[] {
         this.quest = quest;
         const assembly = disassemble(quest.object_code, manual_stack);
         const message: NewAssemblyInput = { type: InputMessageType.NewAssembly, assembly };

src/quest_editor/scripting/assembly.ts

@@ -47,7 +47,15 @@ export function assemble(
     warnings: AssemblyWarning[];
     errors: AssemblyError[];
 } {
-    return new Assembler(assembly, manual_stack).assemble();
+    logger.trace("assemble start");
+
+    const result = new Assembler(assembly, manual_stack).assemble();
+
+    logger.trace(
+        `assemble end with ${result.warnings.length} warnings and ${result.errors.length} errors.`,
+    );
+
+    return result;
 }
 
 class Assembler {

src/quest_editor/scripting/disassembly.ts

@@ -1,14 +1,27 @@
 import { reinterpret_i32_as_f32 } from "../../core/primitive_conversion";
 import { Arg, Segment, SegmentType } from "./instructions";
-import { Kind, Param, StackInteraction } from "./opcodes";
+import { AnyType, Kind, Param, StackInteraction } from "./opcodes";
+import Logger from "js-logger";
+
+const logger = Logger.get("quest_editor/scripting/disassembly");
+
+type ArgWithType = Arg & {
+    /**
+     * Type inferred from the specific instruction used to push this argument onto the stack.
+     */
+    type: AnyType;
+};
 
 /**
- * @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.
+ * @param object_code - The object code to disassemble.
+ * @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(object_code: Segment[], manual_stack: boolean = false): string[] {
+    logger.trace("disassemble start");
+
     const lines: string[] = [];
-    const stack: Arg[] = [];
-    let section_type: SegmentType | undefined;
+    const stack: ArgWithType[] = [];
+    let section_type: SegmentType | undefined = undefined;
 
     for (const segment of object_code) {
         // Section marker.
@@ -65,7 +78,7 @@ export function disassemble(object_code: Segment[], manual_stack: boolean = fals
         } else {
             for (const instruction of segment.instructions) {
                 if (!manual_stack && instruction.opcode.stack === StackInteraction.Push) {
-                    stack.push(...instruction.args);
+                    stack.push(...add_type_to_args(instruction.opcode.params, instruction.args));
                 } else {
                     let args: string[] = [];
 
@@ -81,7 +94,11 @@ export function disassemble(object_code: Segment[], manual_stack: boolean = fals
                             );
                         }
                     } else {
-                        args = args_to_strings(instruction.opcode.params, instruction.args, false);
+                        args = args_to_strings(
+                            instruction.opcode.params,
+                            add_type_to_args(instruction.opcode.params, instruction.args),
+                            false,
+                        );
                     }
 
                     lines.push(
@@ -99,10 +116,22 @@ export function disassemble(object_code: Segment[], manual_stack: boolean = fals
         lines.push("");
     }
 
+    logger.trace(`disassemble end, line count: ${lines.length}`);
     return lines;
 }
 
-function args_to_strings(params: Param[], args: Arg[], stack: boolean): string[] {
+function add_type_to_args(params: Param[], args: Arg[]): ArgWithType[] {
+    const args_with_type: ArgWithType[] = [];
+    const len = Math.min(params.length, args.length);
+
+    for (let i = 0; i < len; i++) {
+        args_with_type.push({ ...args[i], type: params[i].type });
+    }
+
+    return args_with_type;
+}
+
+function args_to_strings(params: Param[], args: ArgWithType[], stack: boolean): string[] {
     const arg_strings: string[] = [];
 
     for (let i = 0; i < params.length; i++) {
@@ -114,35 +143,39 @@ function args_to_strings(params: Param[], args: Arg[], stack: boolean): string[]
             continue;
         }
 
-        switch (type.kind) {
-            case Kind.Float:
-                // Floats are pushed onto the stack as integers with arg_pushl.
-                if (stack) {
-                    arg_strings.push(reinterpret_i32_as_f32(arg.value).toString());
-                } else {
+        if (arg.type.kind === Kind.RegTupRef) {
+            arg_strings.push("r" + arg.value);
+        } else {
+            switch (type.kind) {
+                case Kind.Float:
+                    // Floats are pushed onto the stack as integers with arg_pushl.
+                    if (stack) {
+                        arg_strings.push(reinterpret_i32_as_f32(arg.value).toString());
+                    } else {
+                        arg_strings.push(arg.value.toString());
+                    }
+                    break;
+                case Kind.ILabelVar:
+                    for (; i < args.length; i++) {
+                        arg_strings.push(args[i].value.toString());
+                    }
+                    break;
+                case Kind.RegRefVar:
+                    for (; i < args.length; i++) {
+                        arg_strings.push("r" + args[i].value);
+                    }
+                    break;
+                case Kind.RegRef:
+                case Kind.RegTupRef:
+                    arg_strings.push("r" + arg.value);
+                    break;
+                case Kind.String:
+                    arg_strings.push(JSON.stringify(arg.value));
+                    break;
+                default:
                     arg_strings.push(arg.value.toString());
-                }
-                break;
-            case Kind.ILabelVar:
-                for (; i < args.length; i++) {
-                    arg_strings.push(args[i].value.toString());
-                }
-                break;
-            case Kind.RegRefVar:
-                for (; i < args.length; i++) {
-                    arg_strings.push("r" + args[i].value);
-                }
-                break;
-            case Kind.RegRef:
-            case Kind.RegTupRef:
-                arg_strings.push("r" + arg.value);
-                break;
-            case Kind.String:
-                arg_strings.push(JSON.stringify(arg.value));
-                break;
-            default:
-                arg_strings.push(arg.value.toString());
-                break;
+                    break;
+            }
         }
     }
 

src/quest_editor/scripting/opcodes.ts

@@ -22,7 +22,7 @@ export enum Kind {
 /**
  * Abstract super type of all types.
  */
-type AnyType =
+export type AnyType =
     | ValueType
     | RefType
     | PointerType
@@ -33,40 +33,40 @@ type AnyType =
 /**
  * Purely abstract super type of all value types.
  */
-type ValueType = ByteType | WordType | DWordType | FloatType | LabelType;
+export type ValueType = ByteType | WordType | DWordType | FloatType | LabelType;
 
 /**
  * 8-Bit integer.
  */
-type ByteType = {
+export type ByteType = {
     readonly kind: Kind.Byte;
 };
 
 /**
  * 16-Bit integer.
  */
-type WordType = {
+export type WordType = {
     readonly kind: Kind.Word;
 };
 
 /**
  * 32-Bit integer.
  */
-type DWordType = {
+export type DWordType = {
     readonly kind: Kind.DWord;
 };
 
 /**
  * 32-Bit floating point number.
  */
-type FloatType = {
+export type FloatType = {
     readonly kind: Kind.Float;
 };
 
 /**
  * Abstract super type of all label types.
  */
-type LabelType =
+export type LabelType =
     | ILabelType
     | DLabelType
     | SLabelType
@@ -79,47 +79,47 @@ type LabelType =
 /**
  * Named reference to an instruction.
  */
-type ILabelType = {
+export type ILabelType = {
     readonly kind: Kind.ILabel;
 };
 
 /**
  * Named reference to a data segment.
  */
-type DLabelType = {
+export type DLabelType = {
     readonly kind: Kind.DLabel;
 };
 
 /**
  * Named reference to a string segment.
  */
-type SLabelType = {
+export type SLabelType = {
     readonly kind: Kind.SLabel;
 };
 
 /**
  * String of arbitrary size.
  */
-type StringType = {
+export type StringType = {
     readonly kind: Kind.String;
 };
 
 /**
  * Arbitrary amount of instruction labels.
  */
-type ILabelVarType = {
+export type ILabelVarType = {
     readonly kind: Kind.ILabelVar;
 };
 
 /**
  * Purely abstract super type of all reference types.
  */
-type RefType = RegRefType | RegTupRefType | RegRefVarType;
+export type RefType = RegRefType | RegTupRefType | RegRefVarType;
 
 /**
  * Reference to one or more registers.
  */
-type RegRefType = {
+export type RegRefType = {
     readonly kind: Kind.RegRef;
 };
 
@@ -127,7 +127,7 @@ type RegRefType = {
  * Reference to a fixed amount of consecutive registers of specific types.
  * The only parameterized type.
  */
-type RegTupRefType = {
+export type RegTupRefType = {
     readonly kind: Kind.RegTupRef;
     readonly register_tuples: Param[];
 };
@@ -135,33 +135,33 @@ type RegTupRefType = {
 /**
  * Arbitrary amount of register references.
  */
-type RegRefVarType = {
+export type RegRefVarType = {
     readonly kind: Kind.RegRefVar;
 };
 
 /**
  * Raw memory pointer.
  */
-type PointerType = {
+export type PointerType = {
     readonly kind: Kind.Pointer;
 };
 
 // Singleton type constants.
 // No singleton constant for `RegTupRef` because it is parameterized.
-const TYPE_ANY: AnyType = { kind: Kind.Any };
-const TYPE_BYTE: ByteType = { kind: Kind.Byte };
-const TYPE_WORD: WordType = { kind: Kind.Word };
-const TYPE_DWORD: DWordType = { kind: Kind.DWord };
-const TYPE_FLOAT: FloatType = { kind: Kind.Float };
-const TYPE_LABEL: LabelType = { kind: Kind.Label };
-const TYPE_I_LABEL: ILabelType = { kind: Kind.ILabel };
-const TYPE_D_LABEL: DLabelType = { kind: Kind.DLabel };
-const TYPE_S_LABEL: SLabelType = { kind: Kind.SLabel };
-const TYPE_STRING: StringType = { kind: Kind.String };
-const TYPE_I_LABEL_VAR: ILabelVarType = { kind: Kind.ILabelVar };
-const TYPE_REG_REF: RegRefType = { kind: Kind.RegRef };
-const TYPE_REG_REF_VAR: RegRefVarType = { kind: Kind.RegRefVar };
-const TYPE_POINTER: PointerType = { kind: Kind.Pointer };
+export const TYPE_ANY: AnyType = { kind: Kind.Any };
+export const TYPE_BYTE: ByteType = { kind: Kind.Byte };
+export const TYPE_WORD: WordType = { kind: Kind.Word };
+export const TYPE_DWORD: DWordType = { kind: Kind.DWord };
+export const TYPE_FLOAT: FloatType = { kind: Kind.Float };
+export const TYPE_LABEL: LabelType = { kind: Kind.Label };
+export const TYPE_I_LABEL: ILabelType = { kind: Kind.ILabel };
+export const TYPE_D_LABEL: DLabelType = { kind: Kind.DLabel };
+export const TYPE_S_LABEL: SLabelType = { kind: Kind.SLabel };
+export const TYPE_STRING: StringType = { kind: Kind.String };
+export const TYPE_I_LABEL_VAR: ILabelVarType = { kind: Kind.ILabelVar };
+export const TYPE_REG_REF: RegRefType = { kind: Kind.RegRef };
+export const TYPE_REG_REF_VAR: RegRefVarType = { kind: Kind.RegRefVar };
+export const TYPE_POINTER: PointerType = { kind: Kind.Pointer };
 
 export const MIN_SIGNED_DWORD_VALUE = -Math.pow(2, 31);
 export const MAX_SIGNED_DWORD_VALUE = Math.pow(2, 31) - 1;

src/quest_editor/stores/AsmEditorStore.ts

@@ -99,7 +99,11 @@ export class AsmEditorStore implements Disposable {
         // don't allow changing inline args mode if there are issues
         if (!this.has_issues.val) {
             this._inline_args_mode.val = inline_args_mode;
-            this.update_assembly_settings();
+
+            assembly_analyser.update_settings({
+                manual_stack: !this.inline_args_mode.val,
+            });
+
             this.update_model();
         }
     };
@@ -213,12 +217,6 @@ export class AsmEditorStore implements Disposable {
             this._model.val = undefined;
         }
     }
-
-    private update_assembly_settings(): void {
-        assembly_analyser.update_settings({
-            manual_stack: !this.inline_args_mode.val,
-        });
-    }
 }
 
 export const asm_editor_store = new AsmEditorStore();