The CPU instructions.
A program of the USSC consisted out of a chain of instructions, each instruction pointing to the one succeeding.
Each instruction existed of one word of ten digits with a sign.
From the left these digits contained:
1 & 2 : ic, - the instruction code
3 - 6 : m, - the operand address M, (M-memory)
7 - 10 : c, - the address of the next instruction C, (C-continuation).
M C = address parts of the instructions.
(M) or m = The operand address, digits 3 to 6 of the instruction-word.
(m) = The operand, the value stored in the address M, a signed ten digit number
(C) or c = The address containing the next instruction.
rA, rx and rL = the three registers in which the calculations and the comparisons took place.
(rA),(rX),(rL) = the contents of the registers.
A program in machine-code could look like this:
(a=address of the instruction, ic=instruction code, (m)=operand address, (c)=address of next instruction)
a ic M C meaning:
0200 72 0301 0204 Feed and read punch-card
0204 96 4000 0399 Transfer buffer to interlace adresses in the 4000-band
0399 25 4001 0203 Load register A, rA with first card-word from 4001
0203 05 4006 0208 Load rX with lower part of first card-word from 4006
0208 12 0000 0211 Translate (rA&rX) into machine code to rA
0211 31 0214 0000 Load zero's into rL
0214 82 0300 0500 Compare, when the card-word was empty or contained zeroes, then continue at 0300, else 0500
While the instruction
25 m c loaded register rA with the contents of memory-adress (m) and the program continued in (c),
it had several derivates for different functions obtained by altering single bits:
26 m - - loaded rA with zeros and the program continued on (m), not on (c).
29 m c - used operand-address (m)+(IR0) (+indexregister 0).
-25 m c - used operand-address (m)+(IR1) (+indexregister 1).
-29 m c - used operand-address (m)+(IR2) (+indexregister 2).
25 000K c - transferred (rX) to rA, since 000K was the adress of rX.
An executable program existed of a sequence of 10 digit words in memory,
linked in order of execution by the continuation-adresses.
||German programmers manual|
List of the instruction set of the USSC90
00 - adress of the next instruction in M, jump to (M)
02 - load indexregister with (M), with the address-part of the instruction.
05 - load rX with (m), with the number in memory-address m.
06 - load rX with zeroes
07 - increment indexregister with (M), copy result to M of rA
11 - printer: print line from memory after paper advance
12 - translate RR-card-code to machine-code, translate RR in (rA & rX) to MC in rA
16 - printer: paper advance only
17 - translate machine-code to card/print-code, translate MC in (rA) to RR in rA & rX
20 - logical: (m) OR (rA) to rA
22 - Read-Punch: test read-buffer being written, if yes: call subroutine
23 - call subroutine, (rC) > rA, the instruction is duplicated in rA.
25 - load rA with (m)
26 - load zeroes into rA
27 - Printer: test buffer being printed, if yes: call subroutine
30 - load rL with (m)
31 - load zeroes into rL
32 - shift (rX) & (rA) right N places, rA and rX behave as a circle
35 - logical: (rA) AND (m) to rA
37 - shift (rA) left N places
42 - Card-reader: test buffer loaded, if yes: call subroutine
46 - Read-Punch: transfer read-buffer into memory in the interlace adresses
47 - Card-reader: select stacker
50 - store (rL) to (m)
55 - divide (m) by (rL)
57 - Read-Punch: select stacker
60 - store (rA) to (m)
62 - zero suppress of RR-code in (rA & rX), take away zeroes and commas left of the most significant digit
65 - store (rX) to (m)
67 - stop
70 - add (m) to (rA)
72 - Card-reader: feed one card, read and write to buffer
73 - return from subroutine, jump to (C), the address in the C-part.
75 - substract (m) from (rA)
77 - move (rA) to rL
81 - Read-Punch: execute cycle (read, punch and read), transfer interlace adresses to buffer and punch buffer
82 - compare (rA)=(rL) and branch to (M) or (C)
85 - multiply (rL) x (m) MSD to rA and LSD to rX (Most Significant Digit and Least Significant Digit)
87 - compare (rA) > (rL) and branch to (M) or (C)
96 - Card-reader: transfer buffer into memory to the interlace adresses