From 087d1fe8d6512eb06fab45f8a6024aee4a5a299d Mon Sep 17 00:00:00 2001
From: lichx <lchx751176501@gmail.com>
Date: Fri, 22 Nov 2024 22:33:18 +0800
Subject: [PATCH] =?UTF-8?q?[feature]=20=E6=9B=B4=E6=96=B0=E8=BF=90?=
 =?UTF-8?q?=E8=A1=8C=E9=80=9F=E5=BA=A6=E8=AE=BE=E7=BD=AE=EF=BC=8C=E6=9C=BA?=
 =?UTF-8?q?=E5=99=A8=E7=A0=81=E6=97=81=E5=A2=9E=E5=8A=A0asm=20=E4=BC=98?=
 =?UTF-8?q?=E5=8C=96=E5=B8=83=E5=B1=80=20=E7=AD=89=E7=AD=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/assets/error.png                 | Bin 0 -> 3890 bytes
 src/assets/ok.png                    | Bin 0 -> 3882 bytes
 src/assets/pause.png                 | Bin 0 -> 1841 bytes
 src/components/ControlPanel.vue      | 106 +++++++++++++++++++++----
 src/components/MachineCodeLayout.vue |  39 +++++++++-
 src/components/MemoryLayout.vue      |   3 +-
 src/utils/Complier.ts                |   3 +-
 src/utils/Runner.ts                  | 111 ++++++++++++++++++---------
 8 files changed, 210 insertions(+), 52 deletions(-)
 create mode 100644 src/assets/error.png
 create mode 100644 src/assets/ok.png
 create mode 100644 src/assets/pause.png

diff --git a/src/assets/error.png b/src/assets/error.png
new file mode 100644
index 0000000000000000000000000000000000000000..5365ce3da2549fcf2ac5fd1a9b0ce214a84886af
GIT binary patch
literal 3890
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
AkpKVy

literal 0
HcmV?d00001

diff --git a/src/assets/ok.png b/src/assets/ok.png
new file mode 100644
index 0000000000000000000000000000000000000000..d12c49daf1b5d097a571c732d262d19ed28a22eb
GIT binary patch
literal 3882
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%0Ay=h5#40x};~&B;?b
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

literal 0
HcmV?d00001

diff --git a/src/assets/pause.png b/src/assets/pause.png
new file mode 100644
index 0000000000000000000000000000000000000000..4f55430f9bf7b529c5cac8b3499a2da68899c254
GIT binary patch
literal 1841
zcmeAS@N?(olHy`uVBq!ia0vp^CqS5k4M?tyST_$yF%}28J29*~C-ahlf$g=Yi(^Pd
z+}qn1CyKa>xLnNiH((8(ka|eO=iuZpf!*>7nHTd?mwr2X?P2w+z}k2<^D4C+a{m+>
z4s^5V<p?-DNM+(ulI8f**3i_!4rDTOtPxC@V4CMA>*V0b7rEtljPe47>^pO;S{j;U
zHf8khbaQaLw!^ZNgOSxT<)U11Z$s0X!s1r~Ok71L7TG?NVq}ec{OpP%i^!7+uGMEu
znYcC`JG;`EL*s;E_qQ3@EFvkrvxD0O0wy?%y*0cJ6qYhy&ZoFQp<U-z@;bqQ!D;b>
z!y-@iz1Pp?*f#H1S?u-iYlZJyyxI5OzyJ8-&(i(5|9_Om#&74ZZEuucsqo$U!|&hm
zKaW?lKmIA-Wq*J6(b8CXrD*v_ighgy_vN!zKKgKY3D>5V@f@r-Sw2<rG}|;MOxSy{
zYq{YGVJEiE#a~V{u-!a8*-;`Te^HrlvH;u7sY~ZSH#iZuisz6*weZ$#sb+%{>vRk~
znx9<uVN0A4w`<Z#pp0i-oYiaD6#Y=3(B95lroBJ|!l&(NHu0!p|Jk}K{!+DK^sF-q
zJex%3{I_@lQutosp5r&Qtm`H~9kG$0_%12Dls#hYp&$M;1t?<U`hU&?VwBx;l;WwM
z2i9txoc&p{#qrvt&%cBB9lhl}71<N2_mfOLeu<sl9<ev(>13d?Pa;3XRv)~uJ>tL9
z)&K07?r(cRn(s->46nVjJ!1W#FR%E2f|Rf4JN^HcBhX214<yk2_Xp(aa)JHLUy7#s
zrwOo~41Q8Rfz5e;^AFi2b63~cH5+)$Q)0_BND*Mme6BVByaLap<sCo=11-9>^VD-=
zj^-ztNk9!i)63R<`Uwoj$}Wi|2PZg6jA|bZI+Bu&-8RR4CJcKEpKX7=Yv2BlXRh_%
z|Ni&o$BLSJRwaoyfCYqjU$1ph@9v4*iUu7GO*~O;tIq&S*3V^++?s*K;DXd0r)-$G
ljPlj<Oh%=#2g`x@EvMC4?`a%b46FkgJYD@<);T3K0RVXZ7FYlP

literal 0
HcmV?d00001

diff --git a/src/components/ControlPanel.vue b/src/components/ControlPanel.vue
index e947463..6a81685 100644
--- a/src/components/ControlPanel.vue
+++ b/src/components/ControlPanel.vue
@@ -1,18 +1,32 @@
 <script setup lang="ts">
 
 import {Runner, RunnerState} from "../utils/Runner.ts";
-import {inject} from "vue";
+import {inject, ref} from "vue";
 import {Compiler} from "../utils/Complier.ts";
-let runner:Runner = inject("runner") as Runner;
-console.log(runner);
+
+let runner: Runner = inject("runner") as Runner;
 let compiler = inject("compiler") as Compiler;
+let info = ref("Ready");
+let speed = ref(20);
+let ok = ref(true);
+compiler.AddEventListener("CompileError", (errorType, e) => {
+    info.value = errorType + " " + (e.index + 1) + ": " + e.message;
+    ok.value = false;
+});
+runner.AddEventListener("RunningError", (errorType, e) => {
+    // pc 指向下一条指令 所以这里不用+1 MachineCode 从0开始，所以需要-1
+    info.value = errorType + " " + (e.index - 1) + ": " + e.message;
+    ok.value = false;
+});
+
+
 function compileCode() {
     runner.Stop();
     compiler.CompileCode();
 }
+
 function startOrContinue() {
-    switch (runner.State)
-    {
+    switch (runner.State) {
         case RunnerState.Running:
             break;
         case RunnerState.Step:
@@ -23,16 +37,22 @@ function startOrContinue() {
             break;
     }
 }
+
+function pause() {
+    runner.Pause();
+}
+
 function step() {
-    if(compiler.CodeChanged)
-    {
+    if (compiler.CodeChanged) {
         compiler.CompileCode();
     }
     runner.Step();
 }
+
 function stop() {
     runner.Stop();
 }
+
 function refresh() {
     runner.Refresh();
 }
@@ -40,10 +60,21 @@ function refresh() {
 
 <template>
     <div id="controlPanel">
-        <div></div>
-        <div id="buttons">
+        <div>
+            <div class="info-bar">
+                <img class="type" :class="{invisible : ok}" src="../assets/error.png" alt="error"/>
+                <img class="type" :class="{invisible : !ok}" src="../assets/ok.png" alt="ok"/>
+                <span class="info">{{ info }}</span>
+            </div>
+        </div>
+        <div class="speed">
+            <input class="speed-input" v-model="speed" type="number" min="0" @input="runner.RunningSpeed = speed"/>
+            <span class="speed-text">ms/step</span>
+        </div>
+        <div class="buttons">
             <img class="button" src="../assets/compile.png" alt="编译" @click="compileCode">
             <img class="button" src="../assets/play.png" alt="运行/恢复运行" @click="startOrContinue">
+            <img class="button" src="../assets/pause.png" alt="暂停" @click="pause">
             <img class="button" src="../assets/step.png" alt="步过" @click="step">
             <img class="button" src="../assets/stop.png" alt="停止" @click="stop">
             <img class="button" src="../assets/refresh.png" alt="重新调试" @click="refresh">
@@ -59,18 +90,67 @@ function refresh() {
     flex-direction: row;
     align-items: center;
 }
+
 #controlPanel > :first-child {
     flex: 1;
 }
+
 #controlPanel > :last-child {
     flex: 0;
 }
 
-#buttons{
+.info-bar {
+    font-size: 19px;
+    text-align: left;
+    display: flex;
+    padding: 5px 5px 5px 20px;
+}
+
+.type {
+    width: 20px;
+    height: 20px;
+    margin: 0 3px;
+    padding: 5px;
+}
+
+.info {
+    padding-top: 3px;
+}
+
+.invisible {
+    display: none;
+}
+
+.buttons {
     display: flex;
 }
 
-.button{
+.speed {
+    padding-right: 25px;
+    display: table;
+}
+
+.speed-input {
+    display: table-cell;
+    height: 27px;
+    border: 1px #373737 solid;
+    border-right-width: 0;
+    padding-left: 10px;
+}
+
+.speed-input:focus {
+    outline: none;
+}
+
+.speed-text {
+    height: 21px;
+    width: 70px;
+    display: table-cell;
+    text-align: center;
+    background-color: #373737;
+}
+
+.button {
     flex: 0;
     width: 20px;
     height: 20px;
@@ -78,9 +158,9 @@ function refresh() {
     padding: 5px;
     cursor: pointer;
     border-radius: 5px;
-
 }
-.button:hover{
+
+.button:hover {
     background-color: #555555;
 }
 
diff --git a/src/components/MachineCodeLayout.vue b/src/components/MachineCodeLayout.vue
index 8bd552f..444b776 100644
--- a/src/components/MachineCodeLayout.vue
+++ b/src/components/MachineCodeLayout.vue
@@ -7,15 +7,25 @@ import {Runner, RunnerState} from "../utils/Runner.ts";
 let compiler: Compiler = inject("compiler") as Compiler;
 let runner: Runner = inject("runner") as Runner;
 let machineCode: Ref<string[][], string[][]> = ref([]);
+let asmCode: Ref<string[][], string[][]> = ref([]);
 let currentPC: Ref<number, number> = ref(-1);
 compiler.AddEventListener("CompileFinished", (_) => {
     machineCode.value = Array.from(compiler.PCToMachineCode.values()).map((x) => {
         x = x.slice(2);
         return [x.slice(0, 2), x.slice(2, 4), x.slice(4, 6)];
     });
+    asmCode.value = Array.from(compiler.PCToCode.values()).map((x) => {
+        return x.split(/[\s,]+/).map((x) => {
+            x = x.trim();
+            if (compiler.Labels.has(x)) {
+                return x + '(' + compiler.Labels.get(x)!.toString(10).padStart(2, '0') + ')';
+            }
+            return x;
+        });
+    })
 })
 runner.AddEventListener("PCChanged", (_) => {
-    currentPC.value = runner.State===RunnerState.Stop?-1: runner._processCounter;
+    currentPC.value = runner._processCounter - 1;
 })
 </script>
 
@@ -25,11 +35,15 @@ runner.AddEventListener("PCChanged", (_) => {
         <div id="code-area">
             <div v-for="(instruction,index) in machineCode">
                 <div class="code" :class="{currentCode: index === currentPC}">
-                    <span class="line-number">{{ index + 1 }}</span>
+                    <span class="line-number">{{ index }}</span>
                     <div class="gutter"></div>
                     <span class="mnemonic">{{ instruction[0] }}</span>
                     <span class="operand">{{ instruction[1] }}</span>
                     <span class="operand">{{ instruction[2] }}</span>
+                    <div class="split"></div>
+                    <span class="asm-mnemonic">{{ asmCode[index][0] }}</span>
+                    <span class="asm-operand">{{ asmCode[index][1] }},</span>
+                    <span class="asm-operand">{{ asmCode[index][2] }}</span>
                 </div>
             </div>
         </div>
@@ -81,10 +95,31 @@ span {
 
 .operand {
     color: rgb(224, 108, 117);
+
 }
 
 .gutter {
     display: inline;
     width: 9px;
 }
+
+.split {
+    margin-left: 10px;
+    background-color: #9e9e9e;
+    width: 1px;
+    height: 28px;
+}
+
+.asm-mnemonic {
+    color: rgb(198, 120, 221);
+    margin-left: 10px;
+    padding-right: 10px;
+    width: 50px;
+}
+
+.asm-operand {
+    color: rgb(224, 108, 117);
+    margin-left: 5px;
+    width: 30px;
+}
 </style>
\ No newline at end of file
diff --git a/src/components/MemoryLayout.vue b/src/components/MemoryLayout.vue
index fb2f697..6ab76cc 100644
--- a/src/components/MemoryLayout.vue
+++ b/src/components/MemoryLayout.vue
@@ -96,7 +96,7 @@ let memory = computed(() => {
 }
 
 .register-loose-layout {
-    grid-template-columns: repeat(7, 1fr);
+    grid-template-columns: repeat(8, 1fr);
 }
 
 .register-compact-layout {
@@ -150,6 +150,7 @@ span {
 
 .screen-row {
     color: rgb(224, 188, 105);
+    white-space: nowrap;
 }
 
 .screen-memory {
diff --git a/src/utils/Complier.ts b/src/utils/Complier.ts
index 815217d..dcdaec0 100644
--- a/src/utils/Complier.ts
+++ b/src/utils/Complier.ts
@@ -5,7 +5,6 @@ export class CompileError extends Error {
         super(message);
         this.index = index;
     }
-
     index: number;
 }
 
@@ -204,6 +203,8 @@ export class Compiler {
                         mnemonicAndVals[i] = this.Labels.get(mnemonicAndVals[i])!.toString(16).padStart(2,'0');
                     else
                         mnemonicAndVals[i] = parseInt(mnemonicAndVals[i]).toString(16).padStart(2,'0');
+                if (mnemonicAndVals[1] === 'NaN'||mnemonicAndVals[2] === 'NaN')
+                    throw new CompileError("Invalid operand", index);
                 this.PCToMachineCode.set(pc, Compiler.KeyWordsToMachineCode.get(mnemonicAndVals[0])! + mnemonicAndVals[1] + mnemonicAndVals[2]);
             });
         } catch (e) {
diff --git a/src/utils/Runner.ts b/src/utils/Runner.ts
index 1f74a5a..8a7a6ab 100644
--- a/src/utils/Runner.ts
+++ b/src/utils/Runner.ts
@@ -1,6 +1,15 @@
 import {MemoryManager, Byte} from "./MemoryManager";
 import {Compiler} from "./Complier.ts";
 
+export class RunningError extends Error {
+    constructor(message: string, index: number) {
+        super(message);
+        this.index = index;
+    }
+
+    index: number;
+}
+
 export enum RunnerState {
     Stop,
     Running,
@@ -9,7 +18,7 @@ export enum RunnerState {
 
 export class Runner {
     // 与Compiler 类似的事件机制 要是再来一个我就把这段逻辑单独抽出来
-    //[PCChanged,RegistersChanged]
+    //[PCChanged,RegistersChanged,RunningError(string,RunningError)]
     _events: Map<string, ((arg0: string, arg1?: any) => void)[]> = new Map<string, ((arg0: string, arg1?: any) => void)[]>();
 
     AddEventListener(event: string, callback: (arg0: string, arg1?: any) => void) {
@@ -28,6 +37,7 @@ export class Runner {
     }
 
     State: RunnerState = RunnerState.Stop;
+    _runningSpeed: number = 20;
     _processor: Processor;
     _memory: MemoryManager;
     _processCounter: number = 0;
@@ -35,6 +45,18 @@ export class Runner {
     _stack: [Byte[], number][] = [];
     _intervalId: NodeJS.Timeout | null = null;
 
+    set RunningSpeed(speed: number) {
+        this._runningSpeed = speed;
+        if (this.State === RunnerState.Running) {
+            this.Pause();
+            this.Resume();
+        }
+    }
+
+    get RunningSpeed() {
+        return this._runningSpeed;
+    }
+
     StartInterval() {
         if (this._intervalId === null)
             this._intervalId = setInterval(() => {
@@ -43,7 +65,7 @@ export class Runner {
                     return;
                 }
                 this.RunOneLineCode();
-            }, 20);
+            }, this._runningSpeed);
     }
 
     StopInterval() {
@@ -73,30 +95,44 @@ export class Runner {
         if (this._compiler.PCToCode.has(this._processCounter))
             code = this._compiler.PCToCode.get(this._processCounter) as string;
         else
-            throw new Error("PC out of range");
+            throw new RunningError("PC out of range", 0);
         this._processCounter++;
         let mnemonicAndVals = code.split(/[\s,]+/);
         // 如果指令不合法 Compiler应该会有异常抛出 则不能执行到这里
         if (mnemonicAndVals.length !== 3)
-            throw new Error("Invalid code");
+            throw new RunningError("Invalid code", this._processCounter);
         let mnemonic = mnemonicAndVals[0];
-        function getVal(runner:Runner, val: string) {
+
+        function getVal(runner: Runner, val: string) {
             if (runner._processor._registers.has(val))
                 return val;
-            else if(runner._compiler.Labels.has(val))
+            else if (runner._compiler.Labels.has(val))
                 return runner._compiler.Labels.get(val) as number;
             else {
                 let t = parseInt(val);
-                if(isNaN(t))
-                    throw new Error("Invalid argument");
+                if (isNaN(t)) {
+                    throw new RunningError("Invalid argument", runner._processCounter);
+                }
                 return t;
             }
         }
-        return [mnemonic, getVal(this,mnemonicAndVals[1]), getVal(this,mnemonicAndVals[2])];
+
+        return [mnemonic, getVal(this, mnemonicAndVals[1]), getVal(this, mnemonicAndVals[2])];
     }
 
     RunOneLineCode() {
-        this._processor.RunCode(...this.CommandParsing(), this.GetMemory, this.SetMemory, this.SetPC, this.SaveEnv, this.RestoreEnv);
+        try {
+            this._processor.RunCode(...this.CommandParsing(), this.GetMemory, this.SetMemory, this.SetPC, this.SaveEnv, this.RestoreEnv);
+        }catch (e:any)
+        {
+            console.log(e);
+            e = e as RunningError;
+            if(e === undefined)
+                throw new RunningError("Unknown error",this._processCounter);
+            e.index =  e.index === -1? this._processCounter : e.index;
+            this.Pause();
+            this.Notify("RunningError", e);
+        }
         this.Notify("PCChanged");
         this.Notify("RegistersChanged");
     }
@@ -128,9 +164,16 @@ export class Runner {
         this.RunOneLineCode()
     }
 
+    Pause() {
+        this.State = RunnerState.Stop;
+        this.StopInterval()
+    }
+
     Stop() {
         this.State = RunnerState.Stop;
         this.StopInterval()
+        this._processCounter = 0;
+        this._memory.clear();
     }
 
     Refresh() {
@@ -138,38 +181,31 @@ export class Runner {
     }
 
     GetMemory(t: number): Byte {
-        console.log(this._memory)
         return this._memory.GetVal(t);
     }
 
     SetMemory(t: number, val: Byte): void {
-        console.log("mem Test:")
-        console.log(this)
-        console.log(this._memory)
-
         this._memory.SetVal(t, val);
     }
 
     SaveEnv() {
         if (this._stack.length > 8)
-            throw new Error("Stack overflow");
-        this._stack.push([this._processor.GetRegisters().map(x=>x.Copy()), this._processCounter]);
+            throw new RunningError("Stack overflow",this._processCounter);
+        this._stack.push([this._processor.GetRegisters().map(x => x.Copy()), this._processCounter]);
     }
 
     RestoreEnv() {
         if (this._stack.length === 0) {
-            this.Stop();
+            this.Pause();
             return;
         }
         let [regs, pc] = this._stack.pop()!;
-        console.log('restore',regs);
         this._processor.SetRegisters(regs);
         this._processCounter = pc;
     }
 
     SetPC(addr: number) {
         this._processCounter = addr;
-        console.log("PC set to", addr);
     }
 
     GetRegisters(): Byte[] {
@@ -202,17 +238,15 @@ class Processor {
         if (this._registers.has(register as string))
             return this._registers.get(register as string)!;
         else
-            throw new Error("Invalid register");
+            throw new RunningError("Invalid register",-1);
     }
 
     GetRegisters(): Byte[] {
-        console.log("Get", this._registers.values());
         return Array.from(this._registers.values());
     }
 
     SetRegisters(registers: Byte[]) {
         for (let i = 0; i < 7; i++) {
-            console.log("Set", String.fromCharCode('A'.charCodeAt(0) + i) + 'X',registers[i].value);
             this._registers.get(String.fromCharCode('A'.charCodeAt(0) + i) + 'X')!.SetValue(registers[i]);
         }
     }
@@ -222,7 +256,12 @@ class Processor {
     }
 
     SetRegisterValue(register: string | number, value: number) {
-        this.GetRegister(register).SetValue(value);
+        try {
+            this.GetRegister(register).SetValue(value);
+        }catch (e)
+        {
+            throw new RunningError("Invalid value",-1);
+        }
     }
 
     InRegister(register: string | number): boolean {
@@ -230,11 +269,15 @@ class Processor {
     }
 
     RunCode(mnemonic: string, operandA: number | string, operandB: number | string, getMemory: (addr: number) => Byte, setMemory: (addr: number, value: Byte) => void, setPC: (addr: number) => void, saveEnv: () => void, restoreEnv: () => void) {
-        console.log(mnemonic, operandA, operandB);
-        if(this.InRegister(operandA))
-            console.log(this.GetRegisterValue(operandA));
-        if(this.InRegister(operandB))
-            console.log(this.GetRegisterValue(operandB));
+        {
+            let a = operandA;
+            let b = operandB;
+            if (this.InRegister(a))
+                a = a + '(' + this.GetRegisterValue(a) + ')';
+            if (this.InRegister(b))
+                b = b + '(' + this.GetRegisterValue(b) + ')';
+            console.log(mnemonic,a,b);
+        }
         switch (mnemonic) {
             case "nop":
                 break;
@@ -301,7 +344,6 @@ class Processor {
                 }
                 break;
             case "st":
-                console.log(operandA, operandB);
                 if (this.InRegister(operandA) && typeof operandB === 'number') {
                     setMemory(operandB as number, this.GetRegister(operandA));
                     return;
@@ -311,18 +353,15 @@ class Processor {
                 if (this.InRegister(operandA) && this.InRegister(operandB)) {
                     this.GetRegister(operandA).SetValue(this.GetRegister(operandB));
                     return;
-                }
-                else if(this.InRegister(operandA) && typeof operandB === 'number') {
+                } else if (this.InRegister(operandA) && typeof operandB === 'number') {
                     this.GetRegister(operandA).SetValue(operandB);
                     return;
                 }
                 break;
             case "cp":
-                console.log(operandA, operandB);
                 operandA = this.InRegister(operandA) ? this.GetRegisterValue(operandA) : operandA;
                 operandB = this.InRegister(operandB) ? this.GetRegisterValue(operandB) : operandB;
                 if (typeof operandA === 'number' && typeof operandB === 'number') {
-                    console.log(operandA, operandB);
                     for (let i = 0; i < (this._registers.get("BX")!.GetValue() as number); i++)
                         setMemory(operandB + i, getMemory(operandA + i));
                     return;
@@ -368,7 +407,9 @@ class Processor {
                     return;
                 }
                 break
+            default:
+                throw new RunningError("Invalid mnemonic",-1);
         }
-        throw new Error("Invalid argument");
+        throw new RunningError("Invalid argument",-1);
     }
 }