Remove files that aren't notes
This commit is contained in:
n loewen
parent
3cc41b8b5a
commit
3982ce3254
|
|
@ -1,3 +0,0 @@
|
||||||
[submodule "src/argparser"]
|
|
||||||
path = src/argparser
|
|
||||||
url = https://git.nloewen.com/n/argv-parser.git
|
|
||||||
|
|
@ -1,46 +0,0 @@
|
||||||
# Cardiograph issues
|
|
||||||
|
|
||||||
## Open
|
|
||||||
|
|
||||||
### #1 - Improve CLI interface
|
|
||||||
|
|
||||||
I'm thinking of an interface like this...
|
|
||||||
|
|
||||||
$ ./cpu.js -mc code.bin
|
|
||||||
$ ./cpu.js code.asm
|
|
||||||
$ ./cpu.js --debug code.asm
|
|
||||||
|
|
||||||
Full list of flags I want:
|
|
||||||
|
|
||||||
-d --debug
|
|
||||||
-s --singlestep
|
|
||||||
-p --prettydisplay
|
|
||||||
-mc --machinecode
|
|
||||||
|
|
||||||
### #2 - Startup: Execute `JMP $FF`
|
|
||||||
|
|
||||||
See [2023-08-24](../notes/2023-08-24--dev-notes.md#cpu-start-up)
|
|
||||||
|
|
||||||
... say that there's a 1-byte ROM at $FF.
|
|
||||||
|
|
||||||
- `00-19` - display (5x5)
|
|
||||||
- `1A ` - pointer to display memory
|
|
||||||
- `1B ` - keypad: value of latest key pressed
|
|
||||||
- `1C ` - reserved for future use (bank switching flag)
|
|
||||||
- `1D ` - initial IP
|
|
||||||
- `1D-FE` - free
|
|
||||||
- `FF ` - ROM (unwriteable) - pointer to initial IP
|
|
||||||
|
|
||||||
- store `$1D` at `$FF`
|
|
||||||
- make CPU execute `JMP $FF` on startup
|
|
||||||
- make ROM unwriteable
|
|
||||||
|
|
||||||
More step-by-step:
|
|
||||||
|
|
||||||
- Change memory from a Uint8Array to a regular array,
|
|
||||||
and make every entry { number | { type: 'ROM', value: number }}
|
|
||||||
- Store ROM as an object in machine.config.js
|
|
||||||
- Load ROM data into memory at CPU startup (`startCPU(RAM, ROM)`)
|
|
||||||
|
|
||||||
|
|
||||||
## Closed
|
|
||||||
|
|
@ -1,55 +0,0 @@
|
||||||
# To do — Summary
|
|
||||||
|
|
||||||
This is a quick todo list.
|
|
||||||
|
|
||||||
For extended commentary, see [issues](issues.md).
|
|
||||||
|
|
||||||
## Open
|
|
||||||
|
|
||||||
### Todo
|
|
||||||
|
|
||||||
- Finish WIP on run-cli arg parsing
|
|
||||||
- Pass CYCLE_COUNT as a cli arg
|
|
||||||
|
|
||||||
- (cpu) !! Fix overflow flag
|
|
||||||
- Add a flag for bank-switching to the ~zero-page
|
|
||||||
- Remove run-scripts and add the ability to run `./cpu.js` and `./assembler.js` directly -- cf. [#1](issues.md#1---improve-cli-interface)
|
|
||||||
- [fix] (cpu) Make single-stepping work with simulated keypad
|
|
||||||
|
|
||||||
### Features
|
|
||||||
|
|
||||||
- (cpu) allow arrow keys, too
|
|
||||||
- [fix] (cpu) Execute `JMP $FF` on startup / Implement ROM — see [#2](issues.md#2---startup-execute-jmp-ff)
|
|
||||||
- (assembler) Validate labels
|
|
||||||
- (assembler) Extract debugging to its own module
|
|
||||||
- (cpu) Consider adding a VIP-style keypad-based machine code monitor
|
|
||||||
- (cpu) Add a mode that prints the display as text, but still animates
|
|
||||||
- (cpu) Allow running pre-compiled machine code
|
|
||||||
- (cpu) DRY out addition and subtraction
|
|
||||||
- [Extended system (secret bonus operations)](../notes/2023-08-07--dev-notes.md)
|
|
||||||
- (research) Review CHIP-8
|
|
||||||
- read about the spec / ISA
|
|
||||||
- read these, and add them to the bibliography:
|
|
||||||
- Steve Losh: https://stevelosh.com/blog/2016/12/chip8-input/
|
|
||||||
- https://tonisagrista.com/blog/2021/chip8-spec/
|
|
||||||
|
|
||||||
### Documentation
|
|
||||||
|
|
||||||
- Improve docs for flags register
|
|
||||||
|
|
||||||
### Testing
|
|
||||||
|
|
||||||
- Display (hex) numbers
|
|
||||||
- Greater than
|
|
||||||
- Minimal LOGO-ish interpreter for turtle graphics
|
|
||||||
|
|
||||||
|
|
||||||
## Closed
|
|
||||||
|
|
||||||
- 2023-08-26 - [fix] (logging) - 'undefined operand' situation is caused by assembling to an initial IP of $1C, which is an odd number
|
|
||||||
- (assembler) Pass asm line thru to cpu to print when debugging
|
|
||||||
|
|
||||||
|
|
||||||
## Abandoned
|
|
||||||
|
|
||||||
- (assembler) Return pure machine code when printing to stdout (and not in debug mode)
|
|
||||||
175
readme.md
175
readme.md
|
|
@ -1,175 +0,0 @@
|
||||||
# Cardiograph Mark I — simulator for an imaginary computer
|
|
||||||
|
|
||||||
## Dependencies
|
|
||||||
|
|
||||||
- Node.js
|
|
||||||
- readline-sync
|
|
||||||
|
|
||||||
## Run
|
|
||||||
|
|
||||||
### Assemble
|
|
||||||
|
|
||||||
Hex output:
|
|
||||||
```./run-assembler run source_code.asm```
|
|
||||||
|
|
||||||
Binary output:
|
|
||||||
```./run-assembler runbin source_code.asm```
|
|
||||||
|
|
||||||
Verbose debugging output (hex):
|
|
||||||
```./run-assembler debug source_code.asm```
|
|
||||||
|
|
||||||
### Assemble and run
|
|
||||||
|
|
||||||
With animated display of screen memory:
|
|
||||||
```./run-cpu run source_code.asm```
|
|
||||||
|
|
||||||
With verbose debugging output:
|
|
||||||
```./run-cpu debug source_code.asm```
|
|
||||||
|
|
||||||
With single stepping + pretty-printed display:
|
|
||||||
```./run-cpu step source_code.asm```
|
|
||||||
|
|
||||||
With single stepping + verbose debugging output:
|
|
||||||
```./run-cpu stepdebug source_code.asm```
|
|
||||||
|
|
||||||
|
|
||||||
## Registers and Flags
|
|
||||||
|
|
||||||
- `A` - accumulator
|
|
||||||
- `IP` - instruction pointer (aka program counter)
|
|
||||||
- `FLAGS` - flags: **O**verflow, **N**egative, **Z**ero, **C**arry
|
|
||||||
- in machine language, each flag is given a number:
|
|
||||||
- O = 3
|
|
||||||
N = 2
|
|
||||||
Z = 1
|
|
||||||
C = 0
|
|
||||||
- (bitwise, `0000 = ONZC`)
|
|
||||||
|
|
||||||
|
|
||||||
## Instruction set
|
|
||||||
|
|
||||||
### Operations
|
|
||||||
|
|
||||||
```
|
|
||||||
Hex Mnem. Operand Effect
|
|
||||||
|
|
||||||
00 END (ignored) Halt CPU
|
|
||||||
01 STO literal # mem[lit#] = A
|
|
||||||
02 STO address mem[mem[addr]] = A
|
|
||||||
03 LDA literal # A = lit#
|
|
||||||
04 LDA address A = addr
|
|
||||||
05 ADD literal # A = A + lit#
|
|
||||||
06 ADD address A = A + mem[addr]
|
|
||||||
07 SUB literal # A = A - lit#
|
|
||||||
08 SUB address A = A - mem[addr]
|
|
||||||
09 HOP literal # If A == lit#, skip next op (IP += 4)
|
|
||||||
0A HOP address If A == mem[addr], skip next instruction (IP += 4)
|
|
||||||
0B JMP literal # IP = lit#
|
|
||||||
0C JMP address IP = mem[addr]
|
|
||||||
0D FTG literal # Toggle flag, where flag number == lit#
|
|
||||||
0E FHP literal # Skip next op if flag is set, where flag number == lit#
|
|
||||||
0F NOP (ignored) None
|
|
||||||
```
|
|
||||||
|
|
||||||
- Instructions are two bytes long:
|
|
||||||
one byte for the opcode, one for the operand
|
|
||||||
|
|
||||||
|
|
||||||
### Effects on memory, flags, registers
|
|
||||||
|
|
||||||
```
|
|
||||||
op mem flags IP
|
|
||||||
|
|
||||||
END +2
|
|
||||||
NOP +2
|
|
||||||
|
|
||||||
STO w +2
|
|
||||||
LDA r NZ +2
|
|
||||||
ADD ONZC +2
|
|
||||||
SUB ONZC +2
|
|
||||||
HOP +2/+4
|
|
||||||
JMP arg
|
|
||||||
FTG ONZC +2
|
|
||||||
FHP ONZC +2/+4
|
|
||||||
|
|
||||||
STO r,w +2
|
|
||||||
LDA r,r NZ +2
|
|
||||||
ADD r ONZC +2
|
|
||||||
SUB r ONZC +2
|
|
||||||
HOP r +2/+4
|
|
||||||
JMP r arg
|
|
||||||
FTG r ONZC +2
|
|
||||||
FHP r ONZC +2/+4
|
|
||||||
```
|
|
||||||
|
|
||||||
|
|
||||||
## CPU start-up
|
|
||||||
|
|
||||||
When starting up, the CPU executes a `JMP $FF`.
|
|
||||||
|
|
||||||
Put differently: it starts executing instructions at the address contained in `$FF`.
|
|
||||||
|
|
||||||
## Cardiograph memory map
|
|
||||||
|
|
||||||
- `00-19` - display (5x5)
|
|
||||||
- `1A ` - pointer to display memory
|
|
||||||
- `1B ` - keypad: value of latest key pressed
|
|
||||||
- `1C ` - reserved for future use (bank switching flag)
|
|
||||||
- `1D ` - initial IP
|
|
||||||
- `1D-FE` - free
|
|
||||||
- `FF ` - ROM (unwriteable) pointer to initial IP (not yet implemented)
|
|
||||||
|
|
||||||
## Peripherals
|
|
||||||
|
|
||||||
### Keypad
|
|
||||||
|
|
||||||
The value of the latest keypress on a hex keypad is stored at `$1B`.
|
|
||||||
|
|
||||||
The keypad uses the same layout as the COSMAC VIP (and CHIP-8). The CPU simulator maps those keys onto a Qwerty set:
|
|
||||||
|
|
||||||
```
|
|
||||||
1 2 3 C 1 2 3 4
|
|
||||||
4 5 6 D Q W E R
|
|
||||||
7 8 9 E A S D F
|
|
||||||
A 0 B F Z X C V
|
|
||||||
|
|
||||||
hex pad simulator
|
|
||||||
```
|
|
||||||
|
|
||||||
The arrow keys are also mapped onto the hex keypad:
|
|
||||||
|
|
||||||
```
|
|
||||||
5 ↑
|
|
||||||
7 8 9 ← ↓ →
|
|
||||||
|
|
||||||
hex pad simulator
|
|
||||||
```
|
|
||||||
|
|
||||||
## Assembly language
|
|
||||||
|
|
||||||
ADD $01 ; comments follow a `;`
|
|
||||||
|
|
||||||
ADD $FF ; this is direct addressing
|
|
||||||
ADD ($CC) ; this is indirect addressing
|
|
||||||
|
|
||||||
END ; END and NOP don't require operands
|
|
||||||
; (the assembler will fill in a default value of 0)
|
|
||||||
|
|
||||||
@subroutine ; create a label
|
|
||||||
ADD $01 ; (it must be on the line before the code it names)
|
|
||||||
ADD $02
|
|
||||||
|
|
||||||
JMP @subroutine ; use a label as operand
|
|
||||||
; the label will be replaced with
|
|
||||||
; the address of the label
|
|
||||||
|
|
||||||
#foo $FF ; define a constant
|
|
||||||
; (must be defined before it is referenced)
|
|
||||||
|
|
||||||
ADD #foo ; use a constant as an operand
|
|
||||||
|
|
||||||
LDA * ; `*` is a special label referencing the memory address
|
|
||||||
; where the current line will be stored after assembly
|
|
||||||
|
|
||||||
- Hexadecimal numbers are preceded by a `$`
|
|
||||||
- Whitespace is ignored
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
Subproject commit 584d9dd95f4b1b3c69065826cf96b3cda0cf9e16
|
|
||||||
422
src/assembler.js
422
src/assembler.js
|
|
@ -1,422 +0,0 @@
|
||||||
const { logMemory, num2hex } = require('./logging.js');
|
|
||||||
const {
|
|
||||||
INITIAL_IP_ADDRESS,
|
|
||||||
DISPLAY_ADDR,
|
|
||||||
POINTER_TO_DISPLAY,
|
|
||||||
} = require('./machine.config.js');
|
|
||||||
|
|
||||||
// 1 = verbose
|
|
||||||
// 2 = what i'm currently focusing on
|
|
||||||
// 3 = always print
|
|
||||||
// 4 = silent
|
|
||||||
const DEBUG_LEVEL = 2;
|
|
||||||
let DEBUG; // Turn debugging on/off -- set by assemble()
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} assemblyCode
|
|
||||||
* @param {Boolean} [debug = false]
|
|
||||||
**/
|
|
||||||
exports.assemble = (assemblyCode, debug = false) => {
|
|
||||||
DEBUG = debug;
|
|
||||||
return decodeInstructions(assemblyCode);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Configure pseudo-ops:
|
|
||||||
const ASM_IP_LABEL = '*';
|
|
||||||
const ASM_CONSTANT_PREFIX = '#';
|
|
||||||
const ASM_LABEL_PREFIX = '@';
|
|
||||||
|
|
||||||
const mnemonicsWithOptionalArgs = ['end', 'nop'];
|
|
||||||
const mnemonics2opcodes = {
|
|
||||||
end: { direct: 0, indirect: 0 },
|
|
||||||
sto: { direct: 1, indirect: 2 },
|
|
||||||
lda: { direct: 3, indirect: 4 },
|
|
||||||
add: { direct: 5, indirect: 6 },
|
|
||||||
sub: { direct: 7, indirect: 8 },
|
|
||||||
hop: { direct: 9, indirect: 10 },
|
|
||||||
jmp: { direct: 11, indirect: 12 },
|
|
||||||
ftg: { direct: 13, indirect: 13 },
|
|
||||||
fhp: { direct: 14, indirect: 14 },
|
|
||||||
nop: { direct: 15, indirect: 15 },
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @typedef {('code'|'comment'|'blank')} SourceLineType
|
|
||||||
**/
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @typedef {Object} SourceLineInfo
|
|
||||||
* @property {number} number - line number
|
|
||||||
* @property {string} source - source text
|
|
||||||
* @property {string} sanitized - source text, with comments and whitespace removed
|
|
||||||
* @property {SourceLineType} type - line type
|
|
||||||
* @property {string} [operation] - For code: the first non-whitespace chunk
|
|
||||||
* @property {string} [argument] - For code: the second non-whitespace chunk, if there is one
|
|
||||||
* @property {string} [extraArgument] - For code: the third non-whitespace chunk, if there is one
|
|
||||||
**/
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} source
|
|
||||||
* @returns {Array<SourceLineInfo>}
|
|
||||||
**/
|
|
||||||
function preparseSourceCode(source) {
|
|
||||||
let lines = source.split(/\n/); // returns an array of lines
|
|
||||||
|
|
||||||
const isLineBlank = (l) => { return stripWhitespaceFromEnds(l).length === 0 ? true : false };
|
|
||||||
const isLineComment = (l) => { return stripWhitespaceFromEnds(l).startsWith(';') };
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} l
|
|
||||||
* @returns {SourceLineType}
|
|
||||||
**/
|
|
||||||
const getLineType = (l) => {
|
|
||||||
if (isLineBlank(l)) return 'blank';
|
|
||||||
if (isLineComment(l)) return 'comment';
|
|
||||||
return 'code';
|
|
||||||
}
|
|
||||||
|
|
||||||
return lines.map((line, index) => {
|
|
||||||
dbg(1, ` in: ${line}`);
|
|
||||||
let info = {
|
|
||||||
number: index + 1,
|
|
||||||
source: line,
|
|
||||||
sanitized: stripWhitespaceFromEnds(stripComments(line)),
|
|
||||||
type: getLineType(line),
|
|
||||||
};
|
|
||||||
dbg(1, ` → ${info.number} - ${info.type}: ${info.sanitized}`);
|
|
||||||
dbg(1, ``);
|
|
||||||
|
|
||||||
if (info.type === 'code') {
|
|
||||||
const op_arg_array = info.sanitized.split(/\s+/); // split line into an array of [op, arg, extra_arg]
|
|
||||||
if (op_arg_array[0] !== 'undefined') {
|
|
||||||
info.operation = op_arg_array[0];
|
|
||||||
}
|
|
||||||
if (op_arg_array.length === 2) {
|
|
||||||
info.argument = op_arg_array[1];
|
|
||||||
}
|
|
||||||
if (op_arg_array.length === 3) {
|
|
||||||
info.argument = op_arg_array[1];
|
|
||||||
info.extraArgument = op_arg_array[2];
|
|
||||||
}
|
|
||||||
// If there's too many arguments, throw an error
|
|
||||||
// NB. there's a special case:
|
|
||||||
// lines with the ASM_IP_LABEL can take an extra argument
|
|
||||||
let maxArgs = 2;
|
|
||||||
if (op_arg_array.length > 2 && op_arg_array[1].startsWith(ASM_IP_LABEL)) {
|
|
||||||
maxArgs = 3;
|
|
||||||
}
|
|
||||||
if (op_arg_array.length > maxArgs) {
|
|
||||||
console.error();
|
|
||||||
console.error(`Error: Too many arguments`);
|
|
||||||
console.error(` at line ${info.number}`);
|
|
||||||
process.exit();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return info;
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} arg
|
|
||||||
* @returns {number}
|
|
||||||
**/
|
|
||||||
function decodeNumericOp(arg) {
|
|
||||||
if (arg.startsWith("$")) return hex2num(arg.replace("$", ""));
|
|
||||||
return parseInt(arg);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} op
|
|
||||||
* @param {object} labels // TODO document better
|
|
||||||
* @param {number} IP
|
|
||||||
* @returns {Array<string>} - array of labels
|
|
||||||
**/
|
|
||||||
function handleLabelDefinition(op, IP, labels) {
|
|
||||||
let label = op.substring(1); // strip label prefix
|
|
||||||
|
|
||||||
if (label in labels) {
|
|
||||||
labels[label].pointsToByte = IP;
|
|
||||||
} else {
|
|
||||||
labels[label] = {
|
|
||||||
pointsToByte: IP,
|
|
||||||
bytesToReplace: [],
|
|
||||||
};
|
|
||||||
}
|
|
||||||
dbg(1, ` Label definition:`);
|
|
||||||
dbg(1, ` Points to byte: ${labels[label].pointsToByte}`);
|
|
||||||
dbg(1, ` Bytes to replace: ${labels[label].bytesToReplace}`);
|
|
||||||
dbg(1, ` IP: $${num2hex(IP)}, new code: none`);
|
|
||||||
dbgGroupEnd(1, 'Input line');
|
|
||||||
return labels;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} op
|
|
||||||
* @param {string} arg
|
|
||||||
* @param {number} IP
|
|
||||||
* @returns {Array<string>} - array of constants
|
|
||||||
**/
|
|
||||||
function handleConstantDefinitions(op, arg, IP, constants) {
|
|
||||||
let constantName = op.substring(1); // strip '>'
|
|
||||||
let constantValue = arg;
|
|
||||||
if (constantValue === ASM_IP_LABEL) {
|
|
||||||
constantValue = IP.toString();
|
|
||||||
}
|
|
||||||
constants[constantName] = constantValue;
|
|
||||||
dbg(1, '');
|
|
||||||
dbg(1, `Constants:`);
|
|
||||||
dbg(1, constants);
|
|
||||||
dbg(1, '');
|
|
||||||
return constants;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Assemble source code.
|
|
||||||
*
|
|
||||||
* If the source doesn't explicitly set an address to assemble to,
|
|
||||||
* it will be assembled to the default intial value of the IP,
|
|
||||||
* as specified in `machine.config.js`.
|
|
||||||
* @param {string} source - Assembly source to decode
|
|
||||||
* @return {{ debugInfo: Object, machineCode: Uint8Array }};
|
|
||||||
**/
|
|
||||||
function decodeInstructions(source) {
|
|
||||||
dbg(1, 'Pre-parsing...');
|
|
||||||
let lines = preparseSourceCode(source);
|
|
||||||
dbg(1, '');
|
|
||||||
dbg(1, 'Done pre-parsing.');
|
|
||||||
dbg(1, '');
|
|
||||||
dbg(1, 'Assembling...');
|
|
||||||
|
|
||||||
// Figure out where to start assembly...
|
|
||||||
|
|
||||||
/** @type {number} IP - Destination addr for the next line **/
|
|
||||||
let IP;
|
|
||||||
|
|
||||||
// Check if the source code explicitly sets an address to assemble at
|
|
||||||
// by including a `* [addr]` as the first (non-blank, non-comment) line
|
|
||||||
let idOfFirstLineWithCode = lines.findIndex((el) => el.type === 'code');
|
|
||||||
if (lines[idOfFirstLineWithCode].operation.startsWith(ASM_IP_LABEL)) {
|
|
||||||
IP = parseInt(lines[idOfFirstLineWithCode].argument);
|
|
||||||
} else {
|
|
||||||
IP = INITIAL_IP_ADDRESS;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Initialize arrays to collect assembled code
|
|
||||||
|
|
||||||
/** @type {Array<number>} - Assembled source code, as an array of bytes **/
|
|
||||||
let machineCode = new Array(IP).fill(0);
|
|
||||||
|
|
||||||
let debugInfo = {};
|
|
||||||
|
|
||||||
// Initialize memory-mapped IO -- TODO this should probably be in the CPU, not here
|
|
||||||
machineCode[POINTER_TO_DISPLAY] = DISPLAY_ADDR;
|
|
||||||
|
|
||||||
// Initialize arrays that collect code references that
|
|
||||||
// have to be revisited after our first pass through the source
|
|
||||||
let labels = {};
|
|
||||||
let constants = {};
|
|
||||||
|
|
||||||
|
|
||||||
// Decode line by line...
|
|
||||||
for (let i = 0; i < lines.length; i++) {
|
|
||||||
let line = lines[i];
|
|
||||||
// dbg(2, `line info:`);
|
|
||||||
// dbg(2, line);
|
|
||||||
if (line.type === 'code') {
|
|
||||||
const op = line.operation;
|
|
||||||
|
|
||||||
if (typeof line.argument === 'undefined') {
|
|
||||||
// If this isn't a label definition,
|
|
||||||
// or one of the ops with optional arguments,
|
|
||||||
// then it's an error
|
|
||||||
if (!line.operation.startsWith('@')) {
|
|
||||||
if (mnemonicsWithOptionalArgs.indexOf(line.operation.toLowerCase()) < 0) {
|
|
||||||
console.error('');
|
|
||||||
console.error(`Error: Missing operand ${line.source}`);
|
|
||||||
console.error(` at line ${line.number}`);
|
|
||||||
process.exit();
|
|
||||||
} else {
|
|
||||||
// It *is* one of the special optional-arg ops
|
|
||||||
// So let's fill in the implicit operand with $00
|
|
||||||
line.argument = '0';
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// *** Decode special operations ***
|
|
||||||
|
|
||||||
// Opcodes - Handle label definitions
|
|
||||||
if (op.startsWith(ASM_LABEL_PREFIX)) {
|
|
||||||
labels = handleLabelDefinition(op, IP, labels);
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Opcodes - Handle constant definitions
|
|
||||||
if (op.startsWith(ASM_CONSTANT_PREFIX)) {
|
|
||||||
constants = handleConstantDefinitions(op, line.argument, IP, constants);
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Opcodes - Handle setting value of IP
|
|
||||||
if (op.startsWith(ASM_IP_LABEL)) {
|
|
||||||
IP = parseInt(line.argument);
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
// *** Decode regular operations ***
|
|
||||||
|
|
||||||
/** @type {number|null} decodedOp **/
|
|
||||||
let decodedOp = null;
|
|
||||||
|
|
||||||
/** @type {number|null} decodedArg **/
|
|
||||||
let decodedArg = null;
|
|
||||||
|
|
||||||
/** @typedef {'direct'|'indirect'} AddressingMode **/
|
|
||||||
let addressingMode = 'direct';
|
|
||||||
|
|
||||||
// Now that it can't be a label or a constant, normalize the opcode
|
|
||||||
line.operation = line.operation.toLowerCase();
|
|
||||||
|
|
||||||
// Operands - Handle references to labels
|
|
||||||
if (line.argument.startsWith(ASM_LABEL_PREFIX)) {
|
|
||||||
let label = line.argument.substring(1); // strip label prefix
|
|
||||||
if (label in labels) {
|
|
||||||
dbg(1, `'${label}' already in labels object`);
|
|
||||||
labels[label].bytesToReplace.push(IP + 1);
|
|
||||||
} else {
|
|
||||||
dbg(1, `'${label}' NOT in labels object`);
|
|
||||||
labels[label] = {
|
|
||||||
bytesToReplace: [IP + 1],
|
|
||||||
};
|
|
||||||
}
|
|
||||||
dbg(1, `Label reference:`);
|
|
||||||
dbg(1, ` Points to byte: ${labels[label].pointsToByte}`);
|
|
||||||
dbg(1, ` Bytes to replace: ${labels[label].bytesToReplace}`);
|
|
||||||
decodedArg = 0; // Return 0 for operand for now -- we'll replace it later
|
|
||||||
}
|
|
||||||
|
|
||||||
// Operands - Handle references to the Instruction Pointer
|
|
||||||
if (line.argument === ASM_IP_LABEL) {
|
|
||||||
dbg(1, ` References current IP - ${IP}`);
|
|
||||||
if (typeof line.extraArgument === 'undefined') {
|
|
||||||
decodedArg = IP;
|
|
||||||
} else {
|
|
||||||
decodedArg = IP + decodeNumericOp(line.extraArgument);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Operands - Handle references to constants
|
|
||||||
if (line.argument.startsWith(ASM_CONSTANT_PREFIX)) {
|
|
||||||
dbg(1, `References '${line.argument}'`);
|
|
||||||
if (typeof constants[line.argument.substring(1)] === 'undefined') {
|
|
||||||
console.error();
|
|
||||||
console.error(`Error: Undefined constant '${line.argument}'`);
|
|
||||||
console.error(` at line ${line.number}`);
|
|
||||||
process.exit();
|
|
||||||
}
|
|
||||||
decodedArg = decodeNumericOp(constants[line.argument.substring(1)]); // substring(1) strips '>'
|
|
||||||
}
|
|
||||||
|
|
||||||
// Operands - Handle references to constants in indirect mode
|
|
||||||
if (line.argument.startsWith(`(${ASM_CONSTANT_PREFIX}`)) {
|
|
||||||
addressingMode = "indirect";
|
|
||||||
dbg(1, `(Indirectly) References '${line.argument}'`);
|
|
||||||
let constName = line.argument.replace(`(${ASM_CONSTANT_PREFIX}`, "");
|
|
||||||
constName = constName.replace(")", "");
|
|
||||||
decodedArg = decodeNumericOp(constants[constName]);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Operands - Handle indirect expressions
|
|
||||||
if (decodedArg === null && line.argument.startsWith("(")) {
|
|
||||||
addressingMode = "indirect";
|
|
||||||
let indyTemp = line.argument.replace("(", "").replace(")", "");
|
|
||||||
decodedArg = decodeNumericOp(indyTemp);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Decode regular opcodes
|
|
||||||
if (decodedOp === null) {
|
|
||||||
decodedOp = mnemonics2opcodes[line.operation][addressingMode];
|
|
||||||
}
|
|
||||||
|
|
||||||
// Decode regular operands
|
|
||||||
if (decodedArg === null) {
|
|
||||||
decodedArg = decodeNumericOp(line.argument);
|
|
||||||
}
|
|
||||||
|
|
||||||
machineCode[IP] = decodedOp;
|
|
||||||
machineCode[IP + 1] = decodedArg;
|
|
||||||
|
|
||||||
debugInfo[IP] = {
|
|
||||||
lineNumber: line.number,
|
|
||||||
source: line.source,
|
|
||||||
address: IP,
|
|
||||||
machine: [decodedOp, decodedArg]
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
dbg(3, ``);
|
|
||||||
dbg(3, `Line ${line.number}: ${line.source}`);
|
|
||||||
if (line.argument) {
|
|
||||||
dbg(3, ` Asm operation: ${line.operation.toUpperCase()} ${line.argument}`);
|
|
||||||
} else if (line.operation) {
|
|
||||||
dbg(3, ` Asm operation: ${line.operation.toUpperCase()}`);
|
|
||||||
}
|
|
||||||
|
|
||||||
dbg(3, ` Machine code: $${num2hex(decodedOp)} $${num2hex(decodedArg)}`);
|
|
||||||
dbg(3, ` IP: $${num2hex(IP)}`);
|
|
||||||
IP += 2;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
dbg(1, '');
|
|
||||||
dbgGroup(1, 'Memory before filling in label constants');
|
|
||||||
dbgExec(1, () => logMemory(new Uint8Array(machineCode)));
|
|
||||||
dbgGroupEnd(1);
|
|
||||||
|
|
||||||
// Backfill label references
|
|
||||||
for (let k of Object.keys(labels)) {
|
|
||||||
dbgGroup(1, `${ASM_LABEL_PREFIX}${k}`);
|
|
||||||
let label = labels[k];
|
|
||||||
dbg(1, `Points to byte: ${label.pointsToByte}`);
|
|
||||||
dbg(1, `Bytes to replace: ${label.bytesToReplace}`);
|
|
||||||
dbgGroupEnd(1);
|
|
||||||
for (let j = 0; j < label.bytesToReplace.length; j++) {
|
|
||||||
machineCode[label.bytesToReplace[j]] = label.pointsToByte;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return { 'debugInfo': debugInfo, 'machineCode': new Uint8Array(machineCode) };
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} line
|
|
||||||
* @returns {string}
|
|
||||||
**/
|
|
||||||
function stripComments(line) {
|
|
||||||
return line.replace(/;.+/,"");
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} line
|
|
||||||
* @returns {string}
|
|
||||||
**/
|
|
||||||
function stripWhitespaceFromEnds(line) {
|
|
||||||
line = line.replace(/^\s+/,"");
|
|
||||||
line = line.replace(/\s+$/,"");
|
|
||||||
return line;
|
|
||||||
}
|
|
||||||
|
|
||||||
function hex2num(hex) { return parseInt(hex, 16) };
|
|
||||||
|
|
||||||
// Debug helpers
|
|
||||||
const dbg = (lvl, s) => { if (DEBUG && (lvl >= DEBUG_LEVEL)) console.log(s) };
|
|
||||||
const dbgGroup = (lvl, s) => { if (DEBUG && (lvl >= DEBUG_LEVEL)) console.group(s) };
|
|
||||||
const dbgGroupEnd = (lvl, s) => { if (DEBUG && (lvl >= DEBUG_LEVEL)) console.groupEnd() };
|
|
||||||
const dbgExec = (lvl, func) => { if (DEBUG && (lvl >= DEBUG_LEVEL)) func(); }
|
|
||||||
422
src/cpu.js
422
src/cpu.js
|
|
@ -1,422 +0,0 @@
|
||||||
const readline = require('readline');
|
|
||||||
const readlineSync = require('readline-sync');
|
|
||||||
|
|
||||||
const {
|
|
||||||
INITIAL_IP_ADDRESS,
|
|
||||||
DEFAULT_CYCLE_LIMIT,
|
|
||||||
KEYPAD_ADDR,
|
|
||||||
KEY_MAP,
|
|
||||||
} = require('./machine.config');
|
|
||||||
|
|
||||||
const {
|
|
||||||
num2hex,
|
|
||||||
bool2bit,
|
|
||||||
} = require('./logging.js');
|
|
||||||
const display = require('./display.js');
|
|
||||||
|
|
||||||
// STATE
|
|
||||||
const CPU = {
|
|
||||||
// Core state
|
|
||||||
running: false,
|
|
||||||
IP: INITIAL_IP_ADDRESS,
|
|
||||||
FLAGS: {'C': false, 'Z': false, 'N': false, 'O': false},
|
|
||||||
FLAGNUMS2NAMES: {0: 'C', 1: 'Z', 2: 'N', 3: 'O'},
|
|
||||||
Acc: 0,
|
|
||||||
memory: null,
|
|
||||||
|
|
||||||
// Functions that update core state
|
|
||||||
/** @param {Uint8Array} data */
|
|
||||||
loadMemory: (data) => {
|
|
||||||
CPU.memory = new Uint8Array(256);
|
|
||||||
CPU.memory.set(data, 0);
|
|
||||||
},
|
|
||||||
incrementIP: (offset) => {
|
|
||||||
CPU.previousIP = CPU.IP;
|
|
||||||
CPU.IP = CPU.IP + offset;
|
|
||||||
},
|
|
||||||
setIP: (address) => {
|
|
||||||
CPU.previousIP = CPU.IP;
|
|
||||||
CPU.IP = address;
|
|
||||||
},
|
|
||||||
updateFlagZero: () => { CPU.FLAGS.Z = CPU.Acc === 0; },
|
|
||||||
updateFlagNegative: () => { CPU.Acc & 128 ? CPU.FLAGS.N = true : CPU.FLAGS.N = false },
|
|
||||||
|
|
||||||
// Debug info
|
|
||||||
previousIP: 0,
|
|
||||||
currentInstruction: {
|
|
||||||
opcode: null,
|
|
||||||
operand: null,
|
|
||||||
mnemonic: null,
|
|
||||||
},
|
|
||||||
cycleCounter: 0,
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// FUNCTIONS THAT MODIFY STATE
|
|
||||||
|
|
||||||
const Instructions = {
|
|
||||||
end: () => {
|
|
||||||
CPU.currentInstruction.mnemonic = 'END';
|
|
||||||
CPU.running = false;
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
},
|
|
||||||
|
|
||||||
store_lit: (lit) => {
|
|
||||||
CPU.currentInstruction.mnemonic = 'STO lit';
|
|
||||||
CPU.memory[lit] = CPU.Acc;
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
},
|
|
||||||
|
|
||||||
store_addr: (addr) => {
|
|
||||||
CPU.currentInstruction.mnemonic = `STO addr; @addr: ${num2hex(CPU.memory[addr])}`;
|
|
||||||
CPU.memory[CPU.memory[addr]] = CPU.Acc;
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
},
|
|
||||||
|
|
||||||
load_lit: (lit) => {
|
|
||||||
CPU.currentInstruction.mnemonic = 'LDA lit';
|
|
||||||
CPU.Acc = lit;
|
|
||||||
CPU.updateFlagNegative();
|
|
||||||
CPU.updateFlagZero();
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
},
|
|
||||||
|
|
||||||
load_addr: (addr) => {
|
|
||||||
CPU.currentInstruction.mnemonic = `LDA addr; @ addr: ${num2hex(CPU.memory[addr])}`;
|
|
||||||
CPU.Acc = CPU.memory[addr];
|
|
||||||
CPU.updateFlagNegative();
|
|
||||||
CPU.updateFlagZero();
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
},
|
|
||||||
|
|
||||||
add_lit: (lit) => {
|
|
||||||
CPU.currentInstruction.mnemonic = 'ADD lit';
|
|
||||||
// Calculate sum
|
|
||||||
let sum = CPU.Acc + lit;
|
|
||||||
if (sum > 255) {
|
|
||||||
CPU.FLAGS.C = true;
|
|
||||||
sum = (sum % 255) - 1;
|
|
||||||
} else {
|
|
||||||
CPU.FLAGS.C = false;
|
|
||||||
}
|
|
||||||
// Calculate overflow flag status
|
|
||||||
let bitSixCarry = 0;
|
|
||||||
if ((CPU.Acc & 64) && (lit & 64)) { bitSixCarry = 1; }
|
|
||||||
// let overflow = bitSixCarry ^ (CPU.FLAGS & 8);
|
|
||||||
// FIXME FIXME FIXME
|
|
||||||
// I'm on a plane and can't remember how this works
|
|
||||||
let overflow = 0;
|
|
||||||
if (overflow) {
|
|
||||||
CPU.FLAGS.O = true;
|
|
||||||
} else {
|
|
||||||
CPU.FLAGS.O = false;
|
|
||||||
}
|
|
||||||
CPU.Acc = sum;
|
|
||||||
CPU.updateFlagNegative();
|
|
||||||
CPU.updateFlagZero();
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
},
|
|
||||||
|
|
||||||
add_addr: (addr) => {
|
|
||||||
CPU.currentInstruction.mnemonic = 'ADD addr';
|
|
||||||
// Calculate sum
|
|
||||||
let sum = CPU.Acc + CPU.memory[addr];
|
|
||||||
if (sum > 255) {
|
|
||||||
CPU.FLAGS.C = true;
|
|
||||||
sum = (sum % 255) - 1;
|
|
||||||
} else {
|
|
||||||
CPU.FLAGS.C = false;
|
|
||||||
}
|
|
||||||
// Calculate overflow flag status
|
|
||||||
let bitSixCarry = 0;
|
|
||||||
if ((CPU.Acc & 64) && (addr & 64)) { bitSixCarry = 1; }
|
|
||||||
// let overflow = bitSixCarry ^ (CPU.FLAGS & 8);
|
|
||||||
// FIXME FIXME FIXME
|
|
||||||
// I'm on a plane and can't remember how this works
|
|
||||||
let overflow = 0;
|
|
||||||
if (overflow) {
|
|
||||||
CPU.FLAGS.O = true;
|
|
||||||
} else {
|
|
||||||
CPU.FLAGS.O = false;
|
|
||||||
}
|
|
||||||
CPU.Acc = sum;
|
|
||||||
CPU.updateFlagNegative();
|
|
||||||
CPU.updateFlagZero();
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
},
|
|
||||||
|
|
||||||
sub_lit: (lit) => {
|
|
||||||
CPU.currentInstruction.mnemonic = 'SUB lit';
|
|
||||||
// Calculate sum
|
|
||||||
let sum = CPU.Acc - lit;
|
|
||||||
if (sum < 0) {
|
|
||||||
CPU.FLAGS.C = true;
|
|
||||||
sum = sum + 256;
|
|
||||||
} else {
|
|
||||||
CPU.FLAGS.C = false;
|
|
||||||
}
|
|
||||||
// Calculate overflow flag status
|
|
||||||
let bitSixCarry = 0;
|
|
||||||
if ((CPU.Acc & 64) && (lit & 64)) { bitSixCarry = 1; }
|
|
||||||
// let overflow = bitSixCarry ^ (CPU.FLAGS & 8);
|
|
||||||
// FIXME FIXME FIXME
|
|
||||||
// I'm on a plane and can't remember how this works
|
|
||||||
let overflow = 0;
|
|
||||||
if (overflow) {
|
|
||||||
CPU.FLAGS.O = true;
|
|
||||||
} else {
|
|
||||||
CPU.FLAGS.O = false;
|
|
||||||
}
|
|
||||||
CPU.Acc = sum;
|
|
||||||
CPU.updateFlagNegative();
|
|
||||||
CPU.updateFlagZero();
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
},
|
|
||||||
|
|
||||||
sub_addr: (addr) => {
|
|
||||||
CPU.currentInstruction.mnemonic = 'SUB addr';
|
|
||||||
// Calculate sum
|
|
||||||
let sum = CPU.Acc - CPU.memory[addr];
|
|
||||||
if (sum < 0) {
|
|
||||||
CPU.FLAGS.C = true;
|
|
||||||
sum = sum + 256;
|
|
||||||
} else {
|
|
||||||
CPU.FLAGS.C = false;
|
|
||||||
}
|
|
||||||
// Calculate overflow flag status
|
|
||||||
let bitSixCarry = 0;
|
|
||||||
if ((CPU.Acc & 64) && (addr & 64)) { bitSixCarry = 1; }
|
|
||||||
// let overflow = bitSixCarry ^ (CPU.FLAGS & 8);
|
|
||||||
// FIXME FIXME FIXME
|
|
||||||
// I'm on a plane and can't remember how this works
|
|
||||||
let overflow = 0;
|
|
||||||
if (overflow) {
|
|
||||||
CPU.FLAGS.O = true;
|
|
||||||
} else {
|
|
||||||
CPU.FLAGS.O = false;
|
|
||||||
}
|
|
||||||
CPU.Acc = sum;
|
|
||||||
CPU.updateFlagNegative();
|
|
||||||
CPU.updateFlagZero();
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
},
|
|
||||||
|
|
||||||
hop_lit: (lit) => {
|
|
||||||
CPU.currentInstruction.mnemonic = `HOP lit; IP+2: ${CPU.memory[CPU.IP+2]}, IP+3: ${CPU.memory[CPU.IP+3]}`;
|
|
||||||
if (CPU.Acc === lit) {
|
|
||||||
CPU.incrementIP(4);
|
|
||||||
} else {
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
hop_addr: (addr) => {
|
|
||||||
CPU.currentInstruction.mnemonic = 'HOP addr';
|
|
||||||
if (CPU.Acc === CPU.memory[addr]) {
|
|
||||||
CPU.incrementIP(4);
|
|
||||||
} else {
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
jump_lit: (lit) => {
|
|
||||||
CPU.currentInstruction.mnemonic = 'JMP lit';
|
|
||||||
CPU.setIP(lit);
|
|
||||||
},
|
|
||||||
|
|
||||||
jump_addr: (addr) => {
|
|
||||||
CPU.currentInstruction.mnemonic = 'JMP addr';
|
|
||||||
CPU.setIP(CPU.memory[addr]);
|
|
||||||
},
|
|
||||||
|
|
||||||
flag_toggle: (flagNum) => {
|
|
||||||
if (flagNum === null) {
|
|
||||||
console.error('Invalid flag number');
|
|
||||||
process.exit();
|
|
||||||
}
|
|
||||||
const flagName = CPU.FLAGNUMS2NAMES[flagNum];
|
|
||||||
CPU.currentInstruction.mnemonic = `FTG ${flagName}`;
|
|
||||||
CPU.FLAGS[flagName] = !CPU.FLAGS[flagName];
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
},
|
|
||||||
|
|
||||||
flag_hop: (flagNum) => {
|
|
||||||
if (flagNum === null) {
|
|
||||||
console.error('Invalid flag number');
|
|
||||||
process.exit();
|
|
||||||
}
|
|
||||||
const flagName = CPU.FLAGNUMS2NAMES[flagNum];
|
|
||||||
CPU.currentInstruction.mnemonic = `FHP ${flagName}; IP+2: ${CPU.memory[CPU.IP+2]}, IP+3: ${CPU.memory[CPU.IP+3]}`;
|
|
||||||
if (CPU.FLAGS[CPU.FLAGNUMS2NAMES[flagNum]]) {
|
|
||||||
CPU.incrementIP(4);
|
|
||||||
} else {
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
no_op: () => {
|
|
||||||
CPU.currentInstruction.mnemonic = `NOP`;
|
|
||||||
CPU.incrementIP(2);
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
const opcodes2mnemonics = {
|
|
||||||
0: (operand) => Instructions.end(),
|
|
||||||
1: (operand) => Instructions.store_lit(operand),
|
|
||||||
2: (operand) => Instructions.store_addr(operand),
|
|
||||||
3: (operand) => Instructions.load_lit(operand),
|
|
||||||
4: (operand) => Instructions.load_addr(operand),
|
|
||||||
5: (operand) => Instructions.add_lit(operand),
|
|
||||||
6: (operand) => Instructions.add_addr(operand),
|
|
||||||
7: (operand) => Instructions.sub_lit(operand),
|
|
||||||
8: (operand) => Instructions.sub_addr(operand),
|
|
||||||
9: (operand) => Instructions.hop_lit(operand),
|
|
||||||
10: (operand) => Instructions.hop_addr(operand),
|
|
||||||
11: (operand) => Instructions.jump_lit(operand),
|
|
||||||
12: (operand) => Instructions.jump_addr(operand),
|
|
||||||
13: (operand) => Instructions.flag_toggle(operand),
|
|
||||||
14: (operand) => Instructions.flag_hop(operand),
|
|
||||||
15: (operand) => Instructions.no_op(),
|
|
||||||
};
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Load code into memory and set CPU state to "running"
|
|
||||||
* @param {Uint8Array} code - Machine code to load
|
|
||||||
**/
|
|
||||||
function startCPU(code) {
|
|
||||||
CPU.loadMemory(code);
|
|
||||||
CPU.cycleCounter = 0;
|
|
||||||
CPU.running = true;
|
|
||||||
|
|
||||||
// FIXME: This conflicts with single-stepping
|
|
||||||
// (you can single-step, but keys aren't passed
|
|
||||||
// through to the Cardiograph)
|
|
||||||
//
|
|
||||||
// -> The fix is maybe to remove readlineSync,
|
|
||||||
// and instead stash the keypress into a buffer variable.*
|
|
||||||
// Then have the stepping function check that buffer,
|
|
||||||
// and then clear the buffer, each time it runs.
|
|
||||||
//
|
|
||||||
// * If it's in the set of keys that are relevant
|
|
||||||
// to single-stepping.
|
|
||||||
|
|
||||||
// Start listening for keypresses...
|
|
||||||
readline.emitKeypressEvents(process.stdin);
|
|
||||||
if (process.stdin.setRawMode != null) {
|
|
||||||
process.stdin.setRawMode(true);
|
|
||||||
}
|
|
||||||
process.stdin.on('keypress', (str, key) => { // TODO: is it possible to turn this off again?
|
|
||||||
if (key.sequence === '\x03') process.exit();
|
|
||||||
let name = key.name.toUpperCase();
|
|
||||||
if (name in KEY_MAP) {
|
|
||||||
CPU.memory[KEYPAD_ADDR] = KEY_MAP[name];
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Execute just the next instruction in memory
|
|
||||||
* @param {Object} debugInfo
|
|
||||||
* @param {Boolean} [debug] - Print machine status and the line of code being executed
|
|
||||||
**/
|
|
||||||
async function stepCPU(debugInfo, debug = false, prettyPrintDisplay = false) {
|
|
||||||
if (CPU.IP >= CPU.memory.length) {
|
|
||||||
console.error('HALTING - IP greater than memory size');
|
|
||||||
CPU.running = false;
|
|
||||||
process.exit();
|
|
||||||
} else {
|
|
||||||
CPU.currentInstruction.opcode = CPU.memory[CPU.IP];
|
|
||||||
CPU.currentInstruction.operand = CPU.memory[CPU.IP+1];
|
|
||||||
let executeInstruction = opcodes2mnemonics[CPU.currentInstruction.opcode];
|
|
||||||
if (typeof executeInstruction === 'undefined') {
|
|
||||||
let info = debugInfo[CPU.previousIP];
|
|
||||||
console.error();
|
|
||||||
console.error(`Error: Invalid opcode`);
|
|
||||||
console.error(` Executing $${num2hex(info.machine[0])} $${num2hex(info.machine[1])}`);
|
|
||||||
console.error(` from line ${info.lineNumber}: ${info.source}`);
|
|
||||||
process.exit();
|
|
||||||
}
|
|
||||||
executeInstruction(CPU.currentInstruction.operand);
|
|
||||||
CPU.cycleCounter += 1;
|
|
||||||
}
|
|
||||||
logCPUState(debugInfo, debug, prettyPrintDisplay);
|
|
||||||
if (DEFAULT_CYCLE_LIMIT) { // Temporary limit as a lazy way to halt infinite loops
|
|
||||||
if (CPU.cycleCounter >= DEFAULT_CYCLE_LIMIT) {
|
|
||||||
console.warn(' HALTING - reached cycle limit');
|
|
||||||
CPU.running = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (!CPU.running) process.exit();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {Uint8Array} code - Machine code to run
|
|
||||||
* @param {Object} debugInfo TODO type
|
|
||||||
* @param {Boolean} [debug] - Enable/disable debugging printouts
|
|
||||||
* @param {Boolean} [singleStep]
|
|
||||||
* @param {Boolean} [prettyPrint] - Print display with black and white emoji, instead of in hex
|
|
||||||
* @param {Number} [clockSpeed] - CPU clock speed in milliseconds
|
|
||||||
**/
|
|
||||||
exports.runProgram =
|
|
||||||
(code, debugInfo, debug=false, singleStep=false, prettyPrint=false, clockSpeed=100) => {
|
|
||||||
if (singleStep) {
|
|
||||||
this.singleStepProgram(code, debugInfo, debug, prettyPrint);
|
|
||||||
} else {
|
|
||||||
startCPU(code);
|
|
||||||
// Animate the output by pausing between steps
|
|
||||||
const loop = setInterval(async () => {
|
|
||||||
stepCPU(debugInfo, debug, prettyPrint);
|
|
||||||
if (!CPU.running) {
|
|
||||||
logCPUState(debugInfo, debug, prettyPrint);
|
|
||||||
console.log('Halted');
|
|
||||||
process.exit();
|
|
||||||
}
|
|
||||||
}, clockSpeed);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {Uint8Array} code - Machine code to run
|
|
||||||
* @param {any} debugInfo - TODO
|
|
||||||
* @param {Boolean} [debug] - Enable/disable debugging printouts
|
|
||||||
* @param {Boolean} [prettyPrintDisplay] - Print display using black and white emoji
|
|
||||||
**/
|
|
||||||
exports.singleStepProgram = (code, debugInfo, debug = false, prettyPrintDisplay = false) => {
|
|
||||||
startCPU(code);
|
|
||||||
while (CPU.running) {
|
|
||||||
stepCPU(debugInfo, debug, prettyPrintDisplay);
|
|
||||||
// FIXME: this prevents exiting with Ctrl+C:
|
|
||||||
let key = readlineSync.keyIn('S to step, Q to quit > ', {
|
|
||||||
limit: ['s', 'S', 'q', 'Q'],
|
|
||||||
});
|
|
||||||
if (key.toLowerCase() === 'q') { process.exit(); }
|
|
||||||
console.log();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// FUNCTIONS THAT PULL INFO FROM STATE TO DISPLAY
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {Boolean} [debug] - Enable/disable debugging printouts
|
|
||||||
**/
|
|
||||||
function logCPUState(debugInfo, debug = false, prettyPrintDisplay = false) {
|
|
||||||
debugInfo = debugInfo[CPU.previousIP] !== 'undefined' ? debugInfo[CPU.previousIP] : false;
|
|
||||||
console.group(`Step ${CPU.cycleCounter}`);
|
|
||||||
console.log();
|
|
||||||
if (!debug) console.clear();
|
|
||||||
display.show(CPU.memory, prettyPrintDisplay);
|
|
||||||
console.log();
|
|
||||||
if (debugInfo) {
|
|
||||||
console.log(`Line ${debugInfo.lineNumber}: ${debugInfo.source}`);
|
|
||||||
console.log();
|
|
||||||
}
|
|
||||||
console.log('Mnemonic:', CPU.currentInstruction.mnemonic);
|
|
||||||
console.log(`Machine: $${num2hex(CPU.currentInstruction.opcode)} $${num2hex(CPU.currentInstruction.operand)}`);
|
|
||||||
console.log();
|
|
||||||
console.log(`IP: $${num2hex(CPU.IP)} Acc: $${num2hex(CPU.Acc)} ONZC ${bool2bit(CPU.FLAGS.O)}${bool2bit(CPU.FLAGS.N)}${bool2bit(CPU.FLAGS.Z)}${bool2bit(CPU.FLAGS.C)}`);
|
|
||||||
console.log(`KEY: $${num2hex(CPU.memory[KEYPAD_ADDR])} ${CPU.running ? "running" : "halted" }`);
|
|
||||||
console.log();
|
|
||||||
console.log();
|
|
||||||
console.groupEnd();
|
|
||||||
};
|
|
||||||
|
|
@ -1,22 +0,0 @@
|
||||||
const { POINTER_TO_DISPLAY } = require('./machine.config');
|
|
||||||
const { num2hex } = require('./logging.js');
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Print the contents of display memory
|
|
||||||
* by default, each pixel is shown as a hex number
|
|
||||||
* @param {Uint8Array} mem - CPU memory
|
|
||||||
* @param {Boolean} pretty - Display pixels using black and white emoji circles
|
|
||||||
**/
|
|
||||||
const printDisplay = (mem, pretty=false) => {
|
|
||||||
const disp = mem[POINTER_TO_DISPLAY];
|
|
||||||
const num2pic = (n) => n > 0 ? '⚫' : '⚪';
|
|
||||||
let fmt = (n) => num2hex(n);
|
|
||||||
if (pretty) fmt = (n) => num2pic(n);
|
|
||||||
for (let i = disp; i < disp + 25; i += 5) {
|
|
||||||
console.log(`${fmt(mem[i])} ${fmt(mem[i+1])} ${fmt(mem[i+2])} ${fmt(mem[i+3])} ${fmt(mem[i+4])}`);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
module.exports = {
|
|
||||||
"show": printDisplay,
|
|
||||||
}
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
{
|
|
||||||
"compilerOptions": {
|
|
||||||
"checkJs": true
|
|
||||||
},
|
|
||||||
"exclude": ["node_modules", "**/node_modules/*"]
|
|
||||||
}
|
|
||||||
|
|
@ -1,91 +0,0 @@
|
||||||
/**
|
|
||||||
* Display a table of memory locations.
|
|
||||||
* Call with [start] and [end] indices to display a range.
|
|
||||||
* @param {Uint8Array} mem - Memory to display
|
|
||||||
* @param {number} [start] - A start-index, in decimal
|
|
||||||
* @param {number} [end] - An end-index, in decimal
|
|
||||||
**/
|
|
||||||
const logMemory = (mem, start=0, end=mem.length) => {
|
|
||||||
let top1 = `┌─────────┬────────┬─────────┐`;
|
|
||||||
let top2 = `│ addrs │ opcode │ operand │`;
|
|
||||||
let top3 = `├─────────┼────────┼─────────┤`;
|
|
||||||
let blnk = `│ │ │ │`;
|
|
||||||
let bot1 = `└─────────┴────────┴─────────┘`;
|
|
||||||
console.log(`${top1}\n${top2}\n${top3}`);
|
|
||||||
for (let i = start; i < mem.length; i +=2) {
|
|
||||||
let operand = mem[i+1];
|
|
||||||
if (typeof operand === 'undefined') {
|
|
||||||
console.log(` ${num2hex(i)} ${num2hex(i+1)} │ ${num2hex(mem[i])} │ │`);
|
|
||||||
} else {
|
|
||||||
console.log(`│ ${num2hex(i)} ${num2hex(i+1)} │ ${num2hex(mem[i])} │ ${num2hex(operand)} │`);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Add a blank row every 4 lines:
|
|
||||||
let rowNum = i - start + 2; // Not actually the row number...
|
|
||||||
if ((rowNum % 8 === 0)
|
|
||||||
&& (i < (mem.length - 2))) {
|
|
||||||
console.log(blnk);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
console.log(bot1);
|
|
||||||
}
|
|
||||||
|
|
||||||
const logRunningHeader = () => {
|
|
||||||
console.log();
|
|
||||||
let time = new Date();
|
|
||||||
console.log( `┌─────────────────────┐`);
|
|
||||||
console.log( `│ Running at ${time.toLocaleTimeString('en-GB')} │` );
|
|
||||||
console.log( `└─────────────────────┘`);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {number} num
|
|
||||||
* @returns {string}
|
|
||||||
*/
|
|
||||||
const num2hex = (num) => num.toString(16).toUpperCase().padStart(2, "0");
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} hex
|
|
||||||
* @returns {number}
|
|
||||||
*/
|
|
||||||
const hex2num = (hex) => parseInt(hex, 16);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Convert a number to binary, padded to 8 bits
|
|
||||||
* See here for an explanation: https://stackoverflow.com/questions/9939760/how-do-i-convert-an-integer-to-binary-in-javascript
|
|
||||||
* @param {number} num
|
|
||||||
* @returns {string} binary representation of the input
|
|
||||||
**/
|
|
||||||
const num2bin = (num) => (num >>> 0).toString(2).padStart(8, "0");
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Convert a number to binary, padded to 4 bits
|
|
||||||
* See here for an explanation: https://stackoverflow.com/questions/9939760/how-do-i-convert-an-integer-to-binary-in-javascript
|
|
||||||
* @param {number} num
|
|
||||||
* @returns {string} binary representation of the input
|
|
||||||
**/
|
|
||||||
const num2bin_4bit = (num) => (num >>> 0).toString(2).padStart(4, "0");
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} bin
|
|
||||||
* @returns {number}
|
|
||||||
*/
|
|
||||||
const bin2num = (bin) => parseInt(bin, 2)
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {Boolean} bool
|
|
||||||
* @returns {0|1}
|
|
||||||
**/
|
|
||||||
const bool2bit = (bool) => bool ? 1 : 0;
|
|
||||||
|
|
||||||
|
|
||||||
module.exports = {
|
|
||||||
"logMemory": logMemory,
|
|
||||||
"logRunningHeader": logRunningHeader,
|
|
||||||
"num2hex": num2hex,
|
|
||||||
"hex2num": hex2num,
|
|
||||||
"num2bin": num2bin,
|
|
||||||
"num2bin_4bit": num2bin_4bit,
|
|
||||||
"bin2num": bin2num,
|
|
||||||
"bool2bit": bool2bit,
|
|
||||||
}
|
|
||||||
|
|
@ -1,31 +0,0 @@
|
||||||
module.exports = {
|
|
||||||
"INITIAL_IP_ADDRESS": 29,
|
|
||||||
|
|
||||||
// Use these in CPU:
|
|
||||||
"DISPLAY_ADDR": 0,
|
|
||||||
"KEYPAD_ADDR": 27,
|
|
||||||
// Store the `DISPLAY_ADDR` at this address when assembling:
|
|
||||||
"POINTER_TO_DISPLAY": 26,
|
|
||||||
|
|
||||||
"KEY_MAP": {
|
|
||||||
// Same layout as COSMAC VIP / CHIP-8
|
|
||||||
// (This object maps qwerty keys to hex keys
|
|
||||||
// so that they are arranged in the same layout
|
|
||||||
// as the real keypad)
|
|
||||||
'1':'1', '2':'2', '3':'3', '4':'C',
|
|
||||||
'Q':'4', 'W':'5', 'E':'6', 'R':'D',
|
|
||||||
'A':'7', 'S':'8', 'D':'9', 'F':'E',
|
|
||||||
'Z':'A', 'X':'0', 'C':'B', 'V':'F',
|
|
||||||
|
|
||||||
// Include conventional arrow keys
|
|
||||||
'UP': '5',
|
|
||||||
'LEFT': '7',
|
|
||||||
'DOWN': '8',
|
|
||||||
'RIGHT': '9',
|
|
||||||
},
|
|
||||||
|
|
||||||
// max number of times to step the CPU,
|
|
||||||
// to stop endless loops
|
|
||||||
// 0 = infinite
|
|
||||||
"DEFAULT_CYCLE_LIMIT": 2048,
|
|
||||||
}
|
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,13 +0,0 @@
|
||||||
{
|
|
||||||
"name": "paper-computer",
|
|
||||||
"scripts": {
|
|
||||||
"jsdoc": "./node_modules/.bin/jsdoc"
|
|
||||||
},
|
|
||||||
"devDependencies": {
|
|
||||||
"jsdoc": "^4.0.2",
|
|
||||||
"jsdoc-to-markdown": "^8.0.0"
|
|
||||||
},
|
|
||||||
"dependencies": {
|
|
||||||
"readline-sync": "^1.4.10"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,33 +0,0 @@
|
||||||
#!/usr/bin/env node
|
|
||||||
|
|
||||||
// Run with hex output: `./run-assembler.js run assembly.asm`
|
|
||||||
// Run with binary output: `./run-assembler.js runbin assembly.asm`
|
|
||||||
// Debug: `./run-assembler.js debug assembly.asm`
|
|
||||||
|
|
||||||
const fs = require('fs');
|
|
||||||
const assembler = require('./assembler.js');
|
|
||||||
const { logMemory, num2hex, num2bin } = require('./logging.js');
|
|
||||||
const machineConfig = require('./machine.config.js');
|
|
||||||
|
|
||||||
const mode = process.argv[2];
|
|
||||||
const filename = process.argv[3];
|
|
||||||
const inputFile_str = fs.readFileSync(filename, 'utf8');
|
|
||||||
|
|
||||||
let assembler_output;
|
|
||||||
|
|
||||||
if (mode === "debug") {
|
|
||||||
assembler_output = assembler.assemble(inputFile_str, true);
|
|
||||||
console.log('');
|
|
||||||
console.group("Machine code output");
|
|
||||||
logMemory(assembler_output.machineCode, machineConfig.INITIAL_IP_ADDRESS);
|
|
||||||
console.groupEnd();
|
|
||||||
} else {
|
|
||||||
assembler_output = assembler.assemble(inputFile_str);
|
|
||||||
let output = '';
|
|
||||||
if (mode === 'runbin') { // print binary output
|
|
||||||
assembler_output.machineCode.forEach((n) => output = `${output} ${num2bin(n)}`);
|
|
||||||
} else { // print hex output
|
|
||||||
assembler_output.machineCode.forEach((n) => output = `${output} ${num2hex(n)}`);
|
|
||||||
}
|
|
||||||
console.log(output);
|
|
||||||
}
|
|
||||||
|
|
@ -1,71 +0,0 @@
|
||||||
#!/usr/bin/env node
|
|
||||||
|
|
||||||
// Usage: ./run-cpu.js -f code.asm [--debug] [--step] [--pretty]
|
|
||||||
|
|
||||||
const fs = require('fs');
|
|
||||||
const computer = require('./cpu.js');
|
|
||||||
const assembler = require('./assembler.js');
|
|
||||||
const { logRunningHeader } = require('./logging.js');
|
|
||||||
|
|
||||||
// Load file...
|
|
||||||
|
|
||||||
let filename;
|
|
||||||
try {
|
|
||||||
filename = getArgumentValue('-f', `Missing filename`);
|
|
||||||
} catch (error) {
|
|
||||||
console.error(error.message);
|
|
||||||
process.exit()
|
|
||||||
}
|
|
||||||
|
|
||||||
const inputFile_str = fs.readFileSync(filename, 'utf8');
|
|
||||||
|
|
||||||
|
|
||||||
// Check optional arguments...
|
|
||||||
|
|
||||||
let debug = false;
|
|
||||||
let singleStep = false;
|
|
||||||
let prettyPrint = false;
|
|
||||||
process.argv.forEach((arg) => { if (arg === '--debug') { debug = true } });
|
|
||||||
process.argv.forEach((arg) => { if (arg === '--step') { singleStep = true } });
|
|
||||||
process.argv.forEach((arg) => { if (arg === '--pretty') { prettyPrint = true } });
|
|
||||||
|
|
||||||
let speed = null;
|
|
||||||
process.argv.forEach((arg, index) => {
|
|
||||||
if (arg === '--speed' && process.argv.length > (index -1)) {
|
|
||||||
speed = parseInt(process.argv[index + 1]);
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
|
|
||||||
let assemblerOutput = assembler.assemble(inputFile_str);
|
|
||||||
logRunningHeader();
|
|
||||||
computer.runProgram(
|
|
||||||
assemblerOutput.machineCode,
|
|
||||||
assemblerOutput.debugInfo,
|
|
||||||
debug,
|
|
||||||
singleStep,
|
|
||||||
prettyPrint,
|
|
||||||
speed
|
|
||||||
);
|
|
||||||
|
|
||||||
|
|
||||||
// CLI args TODO
|
|
||||||
// - check if value is the name of another arg
|
|
||||||
// - usage info
|
|
||||||
// - catch nonexistant flags
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} flag - The command line flag, eg. '-f'
|
|
||||||
* @param {string} errorMessage - The error to throw if a value isn't found
|
|
||||||
* @returns {string}
|
|
||||||
**/
|
|
||||||
function getArgumentValue(flag, errorMessage) {
|
|
||||||
let value = null;
|
|
||||||
process.argv.forEach((arg, index) => {
|
|
||||||
if (arg === flag && process.argv.length > (index -1)) {
|
|
||||||
value = process.argv[index + 1];
|
|
||||||
}
|
|
||||||
});
|
|
||||||
if (!value) throw new Error(errorMessage);
|
|
||||||
return value;
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue