The Univac Solid State Computer 90, the software.




                        The program-list printed by the Z-assembler.


Programming the USSC.

Programs were written in machine-code or in a simple symbolic language, called Z-assembler. We programmed directly in machine-code, but in professional settings the programmers would have to use the Z-assembler to get a well defined documentation of their program. The Z-assembler. In this language the programs were written on standardized forms with symbolic instruction-codes and symbolic address-labels. The Z-assembler (the program) translated a symbolic program with labels and mnemonics into executable machine code. It produced a list with both symbolic code and machine code to allow debugging. One advantage of programming in this Z-assembler-language was that a programmer did not have to think about the ongoing rotation of the drum in the calculation the addresses, and that the symbolic labels that interfaced with the standard routines, were recognized. Using the Z-assembler,also allowed different programmers to write together one executable program. Debugging. Debugging was performed with the help of the program ARGUS. This program would scan the machine-code program in memory and detect interrupted program-sequences. Secondly the program KOPRA simulated program-execution and produced a list with the executed instructions, the registers-contents and the used operand. These routines were loaded into the memory-space that was normally occupied by the I/O-routines. In special cases the debugging had to be performed by hand on the USSC, operating the CPU in the one-step-mode. When a program in memory was debugged and was considered to be OK, one could load and run a separate routine that punched the program in machine-code into cards, each card containing 8 instructions.

Debugging.

A program Form.

Subroutines.

Handling a subroutine-call required some special program-lines, since 
there was no stack or stack-pointer available on the USSC. 

A subroutine was called with an instruction in main-program like:   23 0400 1250. 
The subroutine was then entered on address 0400 and this 23-instruction was placed in rA. 
A subroutine would always start with :
  a      ic  m      c
0400 20 0402 0404 =  Perform  an OR with 50 on the 23 instruction code in rA, changing it into a 73 instruction.
0402 50 0000 0000 =  The constant. 
0404 60 0499 0401 =  Write the 73 statement to the exit-address of the subroutine (in this case  0499).    
0499 will then content 73 0400 1250. 

While the original call was:
1205:  23 0400 1250   (=jump to (M) and copy rC to rA)
The return-statement was made: 
0499:  73 0400 1250   (=jump to (C), (C) must be the next instruction of the main-program (the return address).

So 23 0400 1250 meant: 
Call the subroutine on 0400 and continue afterwards the main-program in 1250.  

With this technique subroutines could be nested, but subroutines could never be called recursive, 
since the first return-statement would be overwritten by the second call. 

Menu: .Home .CPU .Punchcards .Calculations .Indexregisters