Bug Computer

The Bug Computer is a simple, educational computer architecture invented by User:Function call without parameters in 2012.
==Naming==
The Bug Computer, although it may seem reasonable, was not named after software bugs well-known by all of us, but rather the bug as a metaphor for the program counter originating from primitive educational computer architectures of similar complexity.
==Architecture==
The Bug Computer reference implementation utilizes a memory consisting of 256 bytes (although it could be extended arbitrarily in other implementations). It also has a (theoretically unbounded) stack which stores nybbles of data.
The system also has two registers, PC and A, and a flag, CF. PC is the program counter and is 8 bits (or different according to the memory size), A is the accumulator (4 bits) and CF is the carry flag.
==Instruction set==
The instruction set is the following:
Mnemonic	Name 	Hex	Function
LDA n 	Load 	0n 	Sets A to the value of n.
SE n 	Skip if equal to 	1n 	Skips the following instruction if A = n.
SNE n 	Skip if not equal to 	2n 	Skips the following instruction if A ≠ n.
DSE n 	Decrement and skip if equal to	3n 	Decrements A (with wrap-around) and skips the following instruction if A = n.
STO +n 	Store 	4n 	Stores the value of A into the lower 4 bits of the byte n cells forward in memory.
STO −n 	Store 	5n 	Stores the value of A into the lower 4 bits of the byte n cells backward in memory.
OPC +n 	Modify opcode 	6n 	Stores the value of A into the upper 4 bits of the byte n cells forward in memory.
OPC −n 	Modify opcode 	7n 	Stores the value of A into the upper 4 bits of the byte n cells backward in memory.
JMP +n 	Jump 	8n 	Jumps n bytes forward.
JMP −n 	Jump 	9n 	Jumps n bytes backward.
JZ +n 	Jump if zero 	An 	Jumps n bytes forward if A = 0.
JZ −n 	Jump if zero 	Bn 	Jumps n bytes backward if A = 0.
RCL +n 	Recall 	Cn 	Recalls the lower 4 bits of the byte n cells forward in memory into A.
RCL −n 	Recall 	Dn 	Recalls the lower 4 bits of the byte n cells backward in memory into A.
HLT 	Halt 	F0 	Halts execution of program.
NOT A 	Not 	F1 	Negates the bits of A.
SC 	Skip if carry 	F2 	Skips the following instruction if CF is set.
SNC 	Skip if no carry 	F3 	Skips the following instruction if CF is clear.
INP A 	Input 	F4 	Waits for user input until a suitable keystroke (see below) is received and stores it in A
OUT A 	Output 	F5 	Outputs the value of A to the screen.
INC A 	Increment 	F6 	Increments the value of A by one (with wrap-around).
DEC A 	Decrement 	F7 	Decrements the value of A by one (with wrap-around).
JMP +A 	Jump (conditional) 	F8 	Jumps forward the number of bytes which is stored in A.
JMP −A 	Jump (conditional) 	F9 	Jumps backward the number of bytes which is stored in A.
PUSH A 	Push 	FA 	Pushes the value of A to the stack.
POP A 	Pop 	FB 	Pops a value from the stack and stores it in A.
none 	none 	FC 	This opcode was left unused (see below).
NOP 	No operation 	FD 	Does nothing.
OUT NL 	Output new-line 	FE 	Outputs a new-line to the screen.
BRK 	Break 	FF 	Stops program execution and quits interpreter.
==Character set==
The system does not use the standard hex alphabet (digits 0–9 and letters A–F) and instead defines a character set which is moderately useful in terms of user communication. In accordance with this, the reference interpreter accepts several different keystrokes for each of the values 10–15.
The characters are coded as per the following:
Value 	Reference symbol	Acceptable keystrokes	Notes
10 (Ah)	Space 	A, Space, Enter 	
11 (Bh)	≡ or + 	B, =, +, *, # 	+ is the preferred symbol; ≡ is for 7-segment displays
12 (Ch)	: 	C, : (colon) 	Useful for displaying time
13 (Dh)	/ 	D, / 	Useful for displaying dates or fractions
14 (Eh)	− 	E, − (dash) 	Useful for negative numbers or as a separator
15 (Fh)	. or , 	F, . (dot), , (comma)	Decimal sign; should be displayed according to regional preference but . (dot) is preferred
==Example program==
Bytecode for a cat program on Bug Computer (in hex):
F4 F5 1A 94 FF
(terminates if a value of 10 (Ah) is received)
Bytecode for a program which adds two numbers and displays the result:
F4 4F F4 4E CC F6 4A CA F7 48 10 98 C4 F5 FF
==Quirks and bugs==
The (reference implementation of the) Bug Computer (although not named after them) has a number of quirks and what some may term “bugs”. I’ve also made a few strange decisions during design, especially because I was 4 years younger then and lacking any formal education on the subject. 
By the way, I’m now planning to release a similar but more reasonably-designed system which I may call the Feature Computer (pun intended).
For example, a bug is to be found in the jump routine in which jump addresses are off by one, a value of 0 (instead of 1) representing normal program flow.
Also a strange thing that I’ve reserved one opcode of arity 0, FC hex, most probably for an instruction which would have put a random value into A, allowing some nondeterminism in the code.
Category:Languages
Category:Educational
Category:Low-level 
Category:Implemented 
Category:2012