Expose vm page + implement OS

components/src/stores/vm.store.ts

@@ -1,20 +1,22 @@
 import { FileSystem } from "@davidsouther/jiffies/lib/esm/fs.js";
 // import { VM as multVM } from "@nand2tetris/simulator/testing/mult.js";
+import { isErr, unwrap } from "@davidsouther/jiffies/lib/esm/result.js";
 import { FIBONACCI } from "@nand2tetris/projects/samples/vm.js";
-import { Dispatch, MutableRefObject, useContext, useMemo, useRef } from "react";
-import { BaseContext } from "./base.context.js";
-import { useImmerReducer } from "../react.js";
 import {
   KeyboardAdapter,
   MemoryAdapter,
   MemoryKeyboard,
 } from "@nand2tetris/simulator/cpu/memory.js";
-import { VMTest } from "@nand2tetris/simulator/test/vmtst.js";
+import { Span } from "@nand2tetris/simulator/languages/base.js";
+import { TST } from "@nand2tetris/simulator/languages/tst.js";
 import { VM, VmInstruction } from "@nand2tetris/simulator/languages/vm.js";
+import { VMTest } from "@nand2tetris/simulator/test/vmtst.js";
+import { Vm, VmFrame } from "@nand2tetris/simulator/vm/vm.js";
+import { Dispatch, MutableRefObject, useContext, useMemo, useRef } from "react";
+import { compare } from "../compare.js";
+import { useImmerReducer } from "../react.js";
+import { BaseContext } from "./base.context.js";
 import { ImmMemory } from "./imm_memory.js";
-import { unwrap } from "@davidsouther/jiffies/lib/esm/result.js";
-import { VmFrame, Vm } from "@nand2tetris/simulator/vm/vm.js";
-import { Span } from "@nand2tetris/simulator/languages/base.js";
 
 export interface VmSim {
   RAM: MemoryAdapter;
@@ -34,27 +36,38 @@ export interface VmPageState {
   vm: VmSim;
   controls: ControlsState;
   test: VMTestSim;
+  files: VMFiles;
 }
 
 export interface ControlsState {
   runningTest: boolean;
-  error: string;
+  exitCode: number | undefined;
+  animate: boolean;
+}
+
+export interface VMFiles {
+  tst: string;
+  cmp: string;
+  out: string;
 }
 
 export type VmStoreDispatch = Dispatch<{
   action: keyof ReturnType<typeof makeVmStore>["reducers"];
   payload?: unknown;
 }>;
 
+export interface VmFile {
+  name: string;
+  content: string;
+}
+
 function reduceVMTest(
   vmTest: VMTest,
   dispatch: MutableRefObject<VmStoreDispatch>
 ): VmSim {
   const RAM = new ImmMemory(vmTest.vm.RAM, dispatch);
   const Screen = new ImmMemory(vmTest.vm.Screen, dispatch);
-  const Keyboard = new MemoryKeyboard(
-    new ImmMemory(vmTest.vm.Keyboard, dispatch)
-  );
+  const Keyboard = new MemoryKeyboard(new ImmMemory(vmTest.vm.RAM, dispatch));
   const highlight = vmTest.vm.derivedLine();
 
   return {
@@ -74,45 +87,145 @@ export function makeVmStore(
   dispatch: MutableRefObject<VmStoreDispatch>
 ) {
   const parsed = unwrap(VM.parse(FIBONACCI));
-  const vm = unwrap(Vm.build(parsed.instructions));
-  const test = new VMTest().with(vm);
+  let vm = unwrap(Vm.build(parsed.instructions));
+  let test = new VMTest().with(vm);
   let useTest = false;
+  let animate = true;
   const reducers = {
+    setTst(state: VmPageState, { tst, cmp }: { tst: string; cmp?: string }) {
+      state.files.tst = tst;
+      state.files.cmp = cmp ?? "";
+    },
+    setExitCode(state: VmPageState, code: number | undefined) {
+      state.controls.exitCode = code;
+      console.log("exit code", code);
+    },
     update(state: VmPageState) {
       state.vm = reduceVMTest(test, dispatch);
       state.test.useTest = useTest;
       state.test.highlight = test.currentStep?.span;
     },
+    setAnimate(state: VmPageState, value: boolean) {
+      state.controls.animate = value;
+    },
+    testStep(state: VmPageState) {
+      state.files.out = test.log();
+    },
+    testFinished(state: VmPageState) {
+      const passed = compare(state.files.cmp.trim(), state.files.out);
+      setStatus(
+        passed
+          ? `Simulation successful: The output file is identical to the compare file`
+          : `Simulation error: The output file differs from the compare file`
+      );
+    },
   };
   const initialState: VmPageState = {
     vm: reduceVMTest(test, dispatch),
     controls: {
-      error: "",
+      exitCode: undefined,
       runningTest: false,
+      animate: true,
     },
     test: {
       useTest,
       highlight: undefined,
     },
+    files: {
+      tst: "",
+      cmp: "",
+      out: "",
+    },
   };
   const actions = {
-    step() {
-      if (useTest) {
-        test.step();
-      } else {
-        vm.step();
+    loadVm(files: VmFile[]) {
+      const parsed = [];
+
+      for (const file of files) {
+        const parseResult = VM.parse(file.content);
+
+        if (isErr(parseResult)) {
+          setStatus(`Parse error: ${parseResult.err.message}`);
+          return false;
+        }
+        parsed.push({
+          name: file.name,
+          instructions: unwrap(parseResult).instructions,
+        });
+      }
+      const buildResult = Vm.buildFromFiles(parsed);
+
+      if (isErr(buildResult)) {
+        setStatus(`Build Error: ${buildResult.err.message}`);
+        return false;
+      }
+
+      vm = unwrap(buildResult);
+      test.vm = vm;
+      test.reset();
+      dispatch.current({ action: "update" });
+      return true;
+    },
+    loadTest(source: string, cmp?: string) {
+      dispatch.current({ action: "setTst", payload: { tst: source, cmp } });
+      const tst = TST.parse(source);
+
+      if (isErr(tst)) {
+        setStatus(`Failed to parse test`);
+        return false;
       }
+      setStatus(`Parsed tst`);
+
+      vm.reset();
+      test = VMTest.from(unwrap(tst));
+      test.vm = vm;
       dispatch.current({ action: "update" });
+      return true;
+    },
+    setAnimate(value: boolean) {
+      animate = value;
+      dispatch.current({ action: "setAnimate", payload: value });
+    },
+    step() {
+      try {
+        let done = false;
+        if (useTest) {
+          done = test.step();
+          dispatch.current({ action: "testStep" });
+          if (done) {
+            dispatch.current({ action: "testFinished" });
+          }
+        } else {
+          const exitCode = vm.step();
+          if (exitCode !== undefined) {
+            done = true;
+            dispatch.current({ action: "setExitCode", payload: exitCode });
+          }
+        }
+        if (animate) {
+          dispatch.current({ action: "update" });
+        }
+        return done;
+      } catch (e) {
+        setStatus(`Runtime error: ${(e as Error).message}`);
+        return true;
+      }
     },
     reset() {
       test.reset();
       vm.reset();
       dispatch.current({ action: "update" });
+      dispatch.current({ action: "setExitCode", payload: undefined });
+      setStatus("Reset");
     },
     toggleUseTest() {
       useTest = !useTest;
       dispatch.current({ action: "update" });
     },
+    initialize() {
+      this.loadTest("repeat {\n\tvmstep;\n}", "");
+      dispatch.current({ action: "update" });
+    },
   };
 
   return { initialState, reducers, actions };

simulator/src/cpu/memory.ts

@@ -1,15 +1,15 @@
 import { assert } from "@davidsouther/jiffies/lib/esm/assert.js";
 import { FileSystem } from "@davidsouther/jiffies/lib/esm/fs.js";
+import { load } from "../fs.js";
 import { op } from "../util/asm.js";
 import { int10, int16, int2 } from "../util/twos.js";
-import { load } from "../fs.js";
 
 export const FORMATS = ["bin", "dec", "hex", "asm"];
 export type Format = typeof FORMATS[number];
 
 export const SCREEN_OFFSET = 0x4000;
-export const SCREEN_ROWS = 512;
-export const SCREEN_COLS = 256;
+export const SCREEN_ROWS = 256;
+export const SCREEN_COLS = 32; // These are 16-bit columns
 export const SCREEN_SIZE = SCREEN_ROWS * SCREEN_COLS;
 export const KEYBOARD_OFFSET = 0x6000;
 
@@ -19,8 +19,8 @@ export interface MemoryAdapter {
   set(index: number, value: number): void;
   reset(): void;
   update(cell: number, value: string, format: Format): void;
-  load(fs: FileSystem, path: string): Promise<void>;
-  loadBytes(bytes: number[]): void;
+  load(fs: FileSystem, path: string, offset?: number): Promise<void>;
+  loadBytes(bytes: number[], offset?: number): void;
   range(start?: number, end?: number): number[];
   map<T>(
     fn: (index: number, value: number) => T,
@@ -95,17 +95,17 @@ export class Memory implements MemoryAdapter {
     }
   }
 
-  async load(fs: FileSystem, path: string) {
+  async load(fs: FileSystem, path: string, offset?: number) {
     try {
-      this.loadBytes(await load(fs, path));
+      this.loadBytes(await load(fs, path), offset);
     } catch (cause) {
       // throw new Error(`ROM32K Failed to load file ${path}`, { cause });
       throw new Error(`Memory Failed to load file ${path}`);
     }
   }
 
-  loadBytes(bytes: number[]): void {
-    this.memory.set(new Int16Array(bytes));
+  loadBytes(bytes: number[], offset?: number): void {
+    this.memory.set(new Int16Array(bytes), offset);
     this.memory.fill(0, bytes.length, this.size);
   }
 
@@ -162,11 +162,11 @@ export class SubMemory implements MemoryAdapter {
   }
 
   load(fs: FileSystem, path: string): Promise<void> {
-    return this.parent.load(fs, path);
+    return this.parent.load(fs, path, this.offset);
   }
 
   loadBytes(bytes: number[]): void {
-    return this.parent.loadBytes(bytes);
+    return this.parent.loadBytes(bytes, this.offset);
   }
 
   range(start?: number, end?: number): number[] {

simulator/src/languages/vm.ts

@@ -167,11 +167,11 @@ vmSemantics.addAttribute<
 });
 
 vmSemantics.addAttribute<VmInstruction>("instruction", {
-  StackInstruction({ op }, { segment }, { value }) {
+  StackInstruction({ op }, { segment }, value) {
     return {
       op: op as "push" | "pop",
       segment,
-      offset: value,
+      offset: Number(value.sourceString),
     };
   },
   OpInstruction({ op }) {
@@ -188,11 +188,11 @@ vmSemantics.addAttribute<VmInstruction>("instruction", {
         | "not",
     };
   },
-  FunctionInstruction(_, { name }, { value: nArgs }) {
-    return { op: "function", name, nVars: nArgs };
+  FunctionInstruction(_, { name }, nVars) {
+    return { op: "function", name, nVars: Number(nVars.sourceString) };
   },
-  CallInstruction(_, { name }, { value: nArgs }) {
-    return { op: "call", name, nArgs };
+  CallInstruction(_, { name }, nArgs) {
+    return { op: "call", name, nArgs: Number(nArgs.sourceString) };
   },
   ReturnInstruction(_) {
     return { op: "return" };

simulator/src/test/vmtst.ts

@@ -73,6 +73,7 @@ export class VMTest extends Test<VMTestInstruction> {
     }
     if (variable === "RAM" && index !== undefined) {
       this.vm.RAM.set(index, value);
+      return;
     }
     if (index !== undefined) {
       this.vm.memory.setSegment(variable as Segment, index, value);
@@ -84,10 +85,12 @@ export class VMTest extends Test<VMTestInstruction> {
         case "arg":
         case "argument":
           this.vm.memory.ARG = value;
+          this.vm.entryArgInitialized = true;
           break;
         case "lcl":
         case "local":
           this.vm.memory.LCL = value;
+          this.vm.entryLocalInitialized = true;
           break;
         case "this":
           this.vm.memory.THIS = value;