SNARK ‘simulator’ a tool used for proving assembler coding
Some computer systems allow programs to be written only in a so-called ‘high-level language’ such as BASIC or PASCAL. Such a language is convenient for solving practical problems precisely because it disguises the actual properties of the underlying hardware with an impenetrable layer of software.
A way out of this difficulty is to use an ‘abstract’ machine – an imaginary computer called the SNARK.
Software Systems
Assignment
The source code for the SNARK computer simulator was from ‘The Fundamentals of Computer Science’ written by Andrew J.T. Colin. At the time of writing this article the only source I can find refers to the BASIC code as being written for the Commodore PET.
The code I have works in GWBASIC so I may have adjusted the code for the PC I was using at the time, I can’t remember if the book edition used as the reference had the code uplifted to a more modern dialect or not.
For this reason I have included my copy of the source code listing at the end of this post, in case anyone is ever looking for it for some reason.
Staffordshire University
School of Computing
HNC (Year 1)
Software Systems
Date: 7th March 1995
I am posting this article on the same date that the assignment paper was written as it was by a coincidence that I started to prepare this post only a few days before the 7th March 2024.
So 29 years have passed for me since I submitted this assignment paper. It doesn’t feel that long at all. Reflecting back, so much has changed and been achieved in computing over these scant years, which is what a great deal of the content of this site is about.
Assignment Text
The Programs for this assignment have been designed for use with the SNARK assembler – detailed in the book ‘Fundementals Of Computer Science’ by A.J.T. Colin.
The SNARK assembler has sixteen instructions which are as follows :
LDA Load the accumulator
ADD Add to the accumulator
AND And with the accumulator
ORA Or with the accumulator
SUB Subtract from the accumulator
STA Store the contents of the accumulator
JMP Jump to location given
BZE Branch if the accumulator = 0
BNZ Branch if the accumulator <> 0
BPL Branch if the accumulator >= 0
BNI Branch if the accumulator < 0
INA Input from buffer to accumulator
OUT Output accumulator to output buffer
LAS Logical shift right contents of
NEG Negate contents of accumulator
END Stop
The SNARK assembler also allows four different addressing modes:
Direct Addressing
Immediate Addressing
Indexed by A
Indexed by B
It has been assumed when designing the programs below that they will be run one after the other in the order below, (i.e. TASK
ONE, TASK TWO … etc).
Running the programs in this way allows the ten numbers entered into memory by TASK ONE, to be accessed by the following tasks when run.
For ease of understanding all the memory locations used by programs below, are addressed using ‘indexed’ addressing.
TASK ONE
Write a program which enables ten numbers to be input and stored in ten successive memory locations in memory.
b) Program Listing
C1 TASK ONE
C2 A PROGRAM TO ENABLE TEN NUMBERS TO BE INPUT AND STORED IN
TEN
C3 SUCCESSIVE MEMORY LOCATIONS.
C4
0 LDA A #10 ; LOAD ACCUMULATOR A WITH 10 (DECIMAL)
1 NEG A ; NEGATE THE CONTENTS OF ACCUMULATOR A
2 INA B ; GET INPUT AND STORE IN ACCUMULATOR B
3 STA B 29A ; STORE CONTENTS OF ACCUMULATOR B IN MEMORY
; LOCATION (29+A)
4 ADD A #1 ; ADD 1 TO THE CONTENTS OF ACCUMULATOR A
5 BNZ A 2 ; BRANCH TO LOCATION 2 IF ACCUMULATOR A IS NOT 0
6 END ; END OF PROGRAM
The program first loads the number 1010 into accumulator A.
The number 1010 is then negated so that accumulator A now holds the value -1010.
A number is then input from the input buffer and is stored into accumulator B. The contents of accumulator B are then stored
into memory location (29 + the contents of accumulator A), i.e. memory location 19.
A 110 is then added to the contents of accumulator A, this has the effect of decrementing the loop counter (Accumulator A). A test is then performed on accumulator A to see if the contents are not 0, if the contents are not 0 the program loops back to line 2 and continues execution.
If accumulator A contains 0 the program ends.
d) Dry Run Of Program
Line Function & Operand Contents of Contents of No. Accumulator A Accumulator B
0 LDA A # 10 A = 10 B = 0
1 NEG A A = -10 B = 0
2 INA B
INPUT : ? 7
A = -10 B = 7
3 STA B 29 A A = -10 B = 7
4 ADD A # 1 A = -9 B = 7
5 BNZ A 2 A = -9 B = 7
2 INA B
INPUT : ? 1
A = -9 B = 1
3 STA B 29 A A = -9 B = 1
4 ADD A # 1 A = -8 B = 1
5 BNZ A 2 A = -8 B = 1
2 INA B
INPUT : ? 14
A = -8 B = 14
3 STA B 29 A A = -8 B = 14
4 ADD A # 1 A = -7 B = 14
5 BNZ A 2 A = -7 B = 14
2 INA B
INPUT : ? 4
A = -7 B = 4
3 STA B 29 A A = -7 B = 4
4 ADD A # 1 A = -6 B = 4
5 BNZ A 2 A = -6 B = 4
2 INA B
INPUT : ? 9
A = -6 B = 9
3 STA B 29 A A = -6 B = 9
4 ADD A # 1 A = -5 B = 9
5 BNZ A 2 A = -5 B = 9
2 INA B
INPUT : ? 18
A = -5 B = 18
3 STA B 29 A A = -5 B = 18
4 ADD A # 1 A = -4 B = 18
5 BNZ A 2 A = -4 B = 18
2 INA B
INPUT : ? 2
A = -4 B = 2
3 STA B 29 A A = -4 B = 2
4 ADD A # 1 A = -3 B = 2
5 BNZ A 2 A = -3 B = 2
2 INA B
INPUT : ? 32
A = -3 B = 32
3 STA B 29 A A = -3 B = 32
4 ADD A # 1 A = -2 B = 32
5 BNZ A 2 A = -2 B = 32
2 INA B
INPUT : ? 27
A = -2 B = 27
3 STA B 29 A A = -2 B = 27
4 ADD A # 1 A = -1 B = 27
5 BNZ A 2 A = -1 B = 27
2 INA B
INPUT : ? 240
A = -1 B = 240
3 STA B 29 A A = -1 B = 240
4 ADD A # 1 A = 0 B = 240
5 BNZ A 2 A = 0 B = 240
6 END A A = 0 B = 240
Contents Of Memory Locations 19 – 28
Memory Location Contents (Dec)
————————————
19 7
20 1
21 14
22 4
23 9
24 18
25 2
26 32
27 27
28 240
Actual Run Of Program
INPUT : ? 7
INPUT : ? 1
INPUT : ? 14
INPUT : ? 4
INPUT : ? 9
INPUT : ? 18
INPUT : ? 2
INPUT : ? 32
INPUT : ? 27
INPUT : ? 240
TASK TWO
Output those ten numbers in reverse order.
B0 Program Listing
C1 TASK 2
C2 A PROGRAM TO OUTPUT 10 NUMBERS STORED IN MEMORY LOCATIONS 19
C3 -28 IN REVERSE ORDER
C4
0 LDA A #10 ; LOAD ACCUMULATOR A WITH 10 (DECIMAL)
1 LDA B 18A ; LOAD ACCUMULATOR B WITH THE CONTENTS OF MEMORY
; LOCATION (18+A)
2 OUT B ; OUTPUT THE CONTENTS OF ACCUMULATOR B
3 SUB A #1 ; SUBTRACT ONE FROM THE CONTENTS OF
; ACCUMULATOR A
4 BNZ A 1 ; BRANCH TO LINE 1 IS ACCUMULATOR A <> 0
5 END ; END OF PROGRAM
The program first loads the number 1010 into accumulator A.
The program then loads the contents of memory location (18 + accumulator A) into accumulator B.
The contents of accumulator B are then sent to the output buffer.
A 110 is then subtracted from the contents of accumulator A, this has the effect of decrementing the loop counter (Accumulator A). A test is then performed on accumulator A to see if the contents are not 0, if the contents are not 0 the program loops back to line 1 and continues execution.
If accumulator A contains 0 the program ends.
d) Dry Run Of Program
Line Function & Operand Contents of Contents of No. Accumulator A Accumulator B
0 LDA A # 10 A = 10 B = 240
1 LDA B 18 A A = 10 B = 240
2 OUT B OUTPUT IS 240
3 SUB A # 1 A = 9 B = 240
4 BNZ A 1 A = 9 B = 240
1 LDA B 18 A A = 9 B = 27
2 OUT B OUTPUT IS 27
3 SUB A # 1 A = 8 B = 27
4 BNZ A 1 A = 8 B = 27
1 LDA B 18 A A = 8 B = 32
2 OUT B OUTPUT IS 32
3 SUB A # 1 A = 7 B = 32
4 BNZ A 1 A = 7 B = 32
1 LDA B 18 A A = 7 B = 2
2 OUT B OUTPUT IS 2
3 SUB A # 1 A = 6 B = 2
4 BNZ A 1 A = 6 B = 2
1 LDA B 18 A A = 6 B = 18
2 OUT B OUTPUT IS 18
3 SUB A 1 A = 5 B = 18
4 BNZ A 1 A = 5 B = 18
1 LDA B 18 A A = 5 B = 9
2 OUT B OUTPUT IS 9
3 SUB A # 1 A = 4 B = 9
4 BNZ A 1 A = 4 B = 9
1 LDA B 18 A A = 4 B = 4
2 OUT B OUTPUT IS 4
3 SUB A # 1 A = 3 B = 4
4 BNZ A 1 A = 3 B = 4
1 LDA B 18 A A = 3 B = 14
2 OUT B OUTPUT IS 14
3 SUB A # 1 A = 2 B = 14
4 BNZ A 1 A = 2 B = 14
1 LDA B 18 A A = 2 B = 1
2 OUT B OUTPUT IS 1
3 SUB A # 1 A = 1 B = 1
4 BNZ A 1 A = 1 B = 1
1 LDA B 18 A A = 1 B = 7
2 OUT B OUTPUT IS 7
3 SUB A # 1 A = 0 B = 7
4 BNZ A 1 A = 0 B = 7
5 END A A = 0 B = 7
Contents Of Memory Locations 19 – 28
Memory Location Contents (Dec)
————————————
19 7
20 1
21 14
22 4
23 9
24 18
25 2
26 32
27 27
28 240
Actual Run Of Program
OUTPUT IS 240
OUTPUT IS 27
OUTPUT IS 32
OUTPUT IS 2
OUTPUT IS 18
OUTPUT IS 9
OUTPUT IS 4
OUTPUT IS 14
OUTPUT IS 1
OUTPUT IS 7
TASK THREE
Add the first six numbers together and output the result.
b) Program Listing
C1 TASK 3
C2 A PROGRAM TO ADD THE FIRST SIX NUMBERS TOGETHER AND OUTPUT
THE RESULT
C3 THE SIX NUMBERS ARE STORED IN MEMORY LOCATIONS 19 – 24
C4
0 LDA B #0 ; LOAD ACCUMULATOR B WITH 0
1 LDA A #6 ; LOAD ACCUMULATOR A WITH 6 (DECIMAL)
2 ADD B 18A ; ADD TO ACCUMULATOR B THE CONTENTS OF MEMORY
; LOCATION (18 + A)
3 SUB A #1 ; SUBTRACT 1 FROM THE CONTENTS OF ACCUMULATOR A
4 BNZ A 2 ; BRANCH TO LINE 2 IF ACCUMULATOR A <> 0
5 OUT B ; OUTPUT THE CONTENTS OF ACCUMULATOR B
6 END ; END OF PROGRAM
The program first loads the number 010 into accumulator B. The program then loads the number 610 into accumulator A.
The contents of memory location (18 + accumulator A) are then added to the contents of accumulator B.
A 110 is then subtracted from the contents of accumulator A, this has the effect of decrementing the loop counter (Accumulator A). A test is then performed on accumulator A to see if the contents are not 0, if the contents are not 0 the program loops back to line 2 and continues execution.
If accumulator A contains 0 the program continues to line 5.
The program then sends the contents of accumulator B to the output buffer. The program then ends.
d) Dry Run Of Program
Line Function & Operand Contents of Contents of No. Accumulator A Accumulator B
0 LDA B# 0 A = 0 B = 0
1 LDA A # 6 A = 6 B = 0
2 ADD B 18 A A = 6 B = 18
3 SUB A # 1 A = 5 B = 18
4 BNZ A 2 A = 5 B = 18
2 ADD B 18 A A = 5 B = 27
3 SUB A # 1 A = 4 B = 27
4 BNZ A 2 A = 4 B = 27
2 ADD B 18 A A = 4 B = 31
3 SUB A # 1 A = 3 B = 31
4 BNZ A 2 A = 3 B = 31
2 ADD B 18 A A = 3 B = 45
3 SUB A # 1 A = 2 B = 45
4 BNZ A 2 A = 2 B = 45
2 ADD B 18 A A = 2 B = 46
3 SUB A # 1 A = 1 B = 46
4 BNZ A 2 A = 1 B = 46
2 ADD B 18 A A = 1 B = 53
3 SUB A # 1 A = 0 B = 53
4 BNZ A 2 A = 0 B = 53
5 OUT B OUTPUT IS 53
6 END A A = 0 B = 53
Contents Of Memory Locations 19 – 28
Memory Location Contents (Dec)
————————————
19 7
20 1
21 14
22 4
23 9
24 18
25 2
26 32
27 27
28 240
Actual Run Of Program
OUTPUT IS 53
TASK FOUR
Subtract the seventh number from the eight and output the result.
b) Program Listing
C1 TASK 4
C2 A PROGRAM TO SUBTRACT THE SEVENTH NUMBER FROM THE EIGTH AND
OUTPUT
C3 THE RESULT. SEVENTH AND EIGHT NUMBER ARE STORED IN MEMORY
LOCATIONS (25 AND 26)
C4
0 LDA A #8 ; LOAD ACCUMULATOR A WITH 8 (DECIMAL)
1 LDA B 18A ; LOAD ACCUMULATOR B WITH THE CONTENTS OF MEMORY
; LOCATION (18+A)
2 SUB A #1 ; SUBTRACT 1 FROM THE CONTENTS OF ACCUMULATOR A
3 SUB B 18A ; SUBTRACT FROM ACCUMULATOR B CONTENTS OF MEMORY
; LOCATION (18+A)
4 OUT B ; OUTPUT THE CONTENTS OF ACCUMULATOR B
5 END ; END OF PROGRAM
The program first loads the number 810 into accumulator A.
The program then loads the contents of memory location (18 + accumulator A) into accumulator B.
A 110 is then subtracted from the contents of accumulator A, this has the effect of decrementing the loop counter (Accumulator A), so the program can access the seventh number input.
The contents of memory location (18 + Accumulator A) are then subtracted from accumulator B.
The program then sends the contents of accumulator B to the output buffer. The program then ends.
d) Dry Run Of Program
Line Function & Operand Contents of Contents of No. Accumulator A Accumulator B
0 LDA A # 8 A = 8 B = 240
1 LDA B 18 A A = 8 B = 32
2 SUB A # 1 A = 7 B = 32
3 SUB B 18 A A = 7 B = 30
4 OUT B OUTPUT IS 30
5 END A A = 7 B = 30
Contents Of Memory Locations 19 – 28
Memory Location Contents (Dec)
————————————
19 7
20 1
21 14
22 4
23 9
24 18
25 2
26 32
27 27
28 240
Actual Run Of Program
OUTPUT IS 30
TASK FIVE
Multiply the ninth number by 4 base 10 and output the result.
b) Program Listing
C1 TASK 5
C2 A PROGRAM TO MULTIPLY THE NINTH NUMBER BY 4 BASE TEN AND
OUTPUT THE RESULT
C3 THE NINTH NUMBER IS STORED IN MEMORY LOCATION 27
C4 NOTE : FOR COMPACTNESS AND SIMPLICITY IT WAS DECIDED TO ADD
THE CONTENTS
C5 OF MEMORY LOCATION 27 TO THE ACCUMULATOR 4 TIMES RATHER THAN
LOOP 4 TIMES
C6
0 LDA A #9 ; LOAD ACCUMULATOR A WITH 9 (DECIMAL)
1 LDA B 18A ; LDA ACCUMULATOR B WITH THE CONTENTS OF MEMORY
; LOCATION (18 + A)
2 ADD B 18A ; ADD TO ACCUMULATOR B THE CONTENTS OF MEMORY
; LOCATION (18 + A)
3 ADD B 18A ; ADD TO ACCUMULATOR B THE CONTENTS OF MEMORY
; LOCATION (18 + A)
4 ADD B 18A ; ADD TO ACCUMULATOR B THE CONTENTS OF MEMORY
; LOCATION (18 + A)
5 OUT B ; OUTPUT THE CONTENTS OF ACCUMULATOR B
6 END ; END OF PROGRAM
The program first loads the number 910 into accumulator B.
The program then loads the contents of memory location (18 + Accumulator A) into accumulator B.
The contents of memory location (18 + accumulator A) are then added to the contents of accumulator B, this action is performed in lines 2,3, and 4. This effectively, along with the load instruction in line 1, multiplies the number stored in memory location (18 + Accumulator A) by 410.
The program then sends the contents of accumulator B to the output buffer. The program then ends.
d) Dry Run Of Program
Line Function & Operand Contents of Contents of No. Accumulator A Accumulator B
0 LDA A # 9 A = 9 B = 240
1 LDA B 18 A A = 9 B = 27
2 ADD B 18 A A = 9 B = 54
3 ADD B 18 A A = 9 B = 81
4 ADD B 18 A A = 9 B = 108
5 OUT B OUTPUT IS 108
6 END A A = 9 B = 108
Contents Of Memory Locations 19 – 28
Memory Location Contents (Dec)
————————————
19 7
20 1
21 14
22 4
23 9
24 18
25 2
26 32
27 27
28 240
Actual Run Of Program
OUTPUT IS 108
TASK SIX
Take the tenth number and logically AND it with the ‘mask’ 11110000 base 2 and output the result.
b) Program Listing
C1 TASK 6
C2 A PROGRAM TO TAKE THE TENTH NUMBER AND LOGICALLY AND IT WITH
THE MASK
C3 (11110000 BINARY – 240 DENARY)
C4
0 LDA A #10 ; LOAD ACCUMULATOR A WITH THE NUMBER 10 (DENARY)
1 LDA B 18A ; LOAD ACCUMULATOR B WITH THE CONTENTS OF MEMORY
; LOCATION (18+A)
2 AND B #240 ; LOGICALLY AND CONTENTS OF ACCUMULATOR B WITH
; THE MASK 11110000
3 OUT B ; OUTPUT THE CONTENTS OF ACCUMULATOR B
4 END ; END OF PROGRAM
The program first loads the number 1010 into accumulator A.
The contents of memory location (18 + accumulator A) are then added to the contents of accumulator B.
The contents of accumulator B are then logically ‘anded’ with the number 24010.
The program then sends the contents of accumulator B to the output buffer. The program then ends.
d) Dry Run Of Program
Line Function & Operand Contents of Contents of No. Accumulator A Accumulator B
0 LDA A # 10 A = 10 B = 240
1 LDA B 18 A A = 10 B = 240
2 AND B# 240 A = 10 B = 240
3 OUT B OUTPUT IS 240
4 END A A = 10 B = 240
Contents Of Memory Locations 19 – 28
Memory Location Contents (Dec)
————————————
19 7
20 1
21 14
22 4
23 9
24 18
25 2
26 32
27 27
28 240
Actual Run Of Program
OUTPUT IS 240
THE SNARK COMPUTER
Barring only the most superficial level, it is impossible to learn anything about programs without actually writing them. Most existing computers are not suitable for the study of machine code programming, for one of two reasons.
Some computer systems allow programs to be written only in a so-called ‘high-level language’ such as BASIC or PASCAL. Such a language is convenient for solving practical problems precisely because it disguises the actual properties of the underlying hardware with an impenetrable layer of software. To give a practical example, many expert BASIC programmers know nothing about the binary system, even though the hardware of the computer uses this notation to express all the numbers in their programs.
Other systems admit machine code programs, but the testing of these programs is laborious and complicated for reasons which have nothing to do with the fundamental principles involved.
A way out of this difficulty is to use an ‘abstract’ machine – an imaginary computer called the SNARK. This forms a useful teaching vehicle because it illustrates many basic principles without introducing unnecessary complexity, and because it can be simulated on an existing computer. This allows programs written for SNARK to be executed in such a way that their detailed operation is immediately apparent.
The execution is done by a special program called a ‘simulator’, which makes the existing computer behave exactly as if it were a SNARK computer.
THE BASIC STRUCTURE OF THE SNARK
Central processing units are made up of registers, arithmetic units and stores. The SNARK is no exception.
It contains an arithmetic unit capable of adding and subtracting 16-bit numbers.
Two 16-bit registers called ‘accumulator A’ and ‘accumulator B’ (‘ACC A’ and ‘ACC B’ for short).
A 9-bit register called the ‘program counter’ (abbreviated to ‘PC’).
An addressable memory, containing up to 512 cells of 16 bits each. The addresses start at 0, and this enables the PC to ‘point’ to any cell uniquely.
The SNARK also includes other registers (such as a memory address register), but because they are effectively concealed from the programmer, we shall not describe them here.
The various functions, with their mnemonics, are as follows.
a: Functions with Addresses
LDA – Load operand to accumulator
STA – Store contents of accumulator
ADD – Add operand to accumulator
SUB – Subtract operand from accumulator
AND – Logical ‘AND’ operand with accumulator
ORA – Logical ‘OR’ operand with accumulator
JMP – Jump unconditionally to stated address
BZE – Jump if selected accumulator = 0
BNZ – Jump if selected accumulator # 0
BMI – Jump if selected accumulator < 0
BPL – Jump if selected accumulator > 0
b: Functions without Addresses
LRS – Shift accumulator one place right logically
NEG – Negate accumulator
INA – Input a number from the keyboard and put it into the selected accumulator
OUT – Print the number in the selected accumulator, on a line by itself
END – Stop
The mode field has four possible values
00 : Immediate mode. The address part is taken as the operand
01 : Direct mode. The operand is taken from the store location specified by the address
10 : Index by accumulator A. The operand is taken from the cell pointed to by the sum of the address part and the current contents of accumulator A.
11 : Index by accumulator B. The description is similar to the one above, except that accumulator B is used to calculate the address.
Note that STA and the jump instructions do not allow the immediate mode.
When started, the system will accept comment lines, program lines or any of a number of ‘directives’ which control the SNARK operating system.
(1) Comment lines A comment line starts with a C followed by a number in the range 1 to 20 and some arbitrary text. Comment lines are stored in the sequence of their numbers irrespective of the order in which they are typed. A comment line with a particular number will replace a previously entered comment with the same number.
(2) Program lines A program line consists of a labelled item, as defined in the previous section. Each item is sent to the SNARK store cell whose address is given at the start of the program line, so that, for example, the item in the program line
7 LDAB#46
is sent to cell 7.
A program line with a particular number will replace a previously entered line with the same number. A line can be deleted by typing its number and nothing else. Note that program lines will generally have consecutive numbers. Unlike BASIC, new program lines may not in general be inserted between existing ones without rewriting the entire program. This is because the numbers represent addresses, not labels as in BASIC.
(3) DUMP This command will write all the material (comment and program lines) typed so far on to a cassette tape, whence it may be retrieved later by a LOAD directive.
( 4) LOAD The LOAD directive will read a SNARK program back from a cassette tape. As it is read, the program is listed.
(5) WIPE All comment and program lines are deleted.
(6) LIST ALL All comments and program lines are displayed.
(7) LC All comment lines are listed and displayed.
(8) LIST n-m m and n are integers in the range 0 to 127. Program lines n to m (inclusive) are listed.
(9) RUN The present program is translated from its source into binary and run. The details of the run are elicited by a brief dialogue.
(a)
(b)
(c)
DISPLAY ON? If the reply is ‘YES’, (or Y) then each instruction and its results are displayed as the instruction is obeyed.
SINGLE SHOT? If the reply is ‘YES’, the program is executed one instruction at a time. Each instruction is initiated by typing any key except ‘B’.
START ADDRESS? The reply (which should be an integer) indicates the address at which execution should start. Execution can be stopped at any time by typing ‘B’ (for ‘break’).
The translation runs at about 2 program lines per second. It is omitted if the source program has not been altered since the last translation.
Provided that no translation has taken place, a program can safely be restarted after a break by specifying the start address ‘-1 ‘.
(10) TRANSLATE This directive forces the translation process. It is useful in circumstances where a new translation is necessary but would have been omitted by the RUN directive. A possible case in point would be the initialisation of a self-modifying program.
( 11) PM m-n This directive generates a post mortem dump of registers m-n of the SNARK store. Each cell is displayed (a) as an instruction, and (b) as a decimal number.
SNARK SIMULATOR FOR THE IBM PC (GWBASIC/BASICA) CODE LISTING
Now available from my GitHub repository here
