lmc-interpreter

This is a simple interpreter/simulator for the Little Man Computing (LMC) architecture written in Typescript.

Components:

• parser
• interpreter

Installation

npm install lmc-interpreter

yarn add lmc-interpreter

pnpm add lmc-interpreter

Usage

import Interpreter from "./interpreter/Interpreter"; // or: Interpreter from "lmc-interpreter"
import Parser from "./parser/Parser"; // or: Parser from "lmc-interpreter"

// Parse a program
const parser = new Parser({
    program: `inp;out;add two;out;two dat 2`, // INP, OUT, ADD TWO, OUT, TWO DAT 2
    comments: {
        enabled: true,
        sequence: "//"
    },
    splitLines: {
        enabled: true,
        sequence: ";"
    }
});
const result = parser.parse();

// Interpret a program
// Note: the memory will not be reset upon .run() calls, so you may want to create a new Interpreter instance for each program
const interpreter = new Interpreter({
    program: result.instructions,
    events: {
        onInput: () => {
            const input = Math.floor(Math.random() * 9) + 1;
            console.log(`> Input: ${input}`);
            return input
        },
        onOutput: (value) => {
            console.log(`> Output: ${value}`);
        },
        onFinished: () => {
            console.log("> Finished!");
        }
        // onDump = dump per step
        // onLog = logs/actions
    },
    memorySize: 100
});
interpreter.run();

View example here.

Parser

Instructions

| Code | Instruction | Description | | ---- | ----------- | ----------- | | 0 | HLT | Stop/exit | | 1 | ADD | Adds the contents of the memory address provided to the Accumulator | | 2 | SUB | Subtracts the contents of the memory address provided from the Accumulator | | 3 | STA/STO | Stores the contents of the Accumulator in the memory address provided | | 4 | | Unused, throws an error | | 5 | LDA | Loads the contents of the memory address provided into the Accumulator | | 6 | BRA | Branches to the memory address provided | | 7 | BRZ | Branches to the memory address provided if the Accumulator is zero | | 8 | BRP | Branches to the memory address provided if the Accumulator is positive | | 9 | INP/OUT | Input (default 1)/Output (default 2), Codes | | 9 | OTC | Output Character, Codes |

All instructions are inherited from PeterHigginson.co.uk's Little Man Computing implementation.

I/O Codes

| Code | Description | | ---- | ----------- | | 1 | Input | | 2 | Output | | 22 | Output Character (OTC only, assigned by default) |

Syntax

The parser expects the following syntax for instructions:

<label?> <instruction> <operand?>

Using a space to split the tokens, this prevents labels from containing spaces as they will not be tokenised correctly. Read more here: Labels

Comments

The parser optionally supports comments using the # character. Comments can be placed at the end of a line or on a line by themselves.

Any content after the # character is ignored.

Split Lines

The parser optionally supports splitting lines using the ; character. This allows for multiple instructions to be placed on a single line.

Labels

Labels are optional and can be used to reference memory addresses.

Labels must fit the following syntax:

• alphanumeric; tokensiation is based on spaces
• can contain underscores
• must not start with a number; to prevent confusion with memory addresses
• must not match an instruction; to prevent confusion with instructions; <label> <opcode> v. <opcode> <operand> is identified by identifying the opcode position.

Interpreter

In comparison to Peter Higginson's implementation, this interpreter has the following fundamental differences:

• unrestricted sizes (memory, accumulator, etc.)