Up to this point we have only considered the running of programs written in the Atlas Assembler – Atlas Basic Language (ABL). However, a large number of other language compilers were written for Atlas 1, not least owing to the presence of the Brooker-Morris COMPILER COMPILER which transformed the effort involved in writing compilers for Atlas. Most of these compilers have now been lost to posterity although it may be feasible to resurrect some of them one day.

In this section, we consider the limited number of compilers which have been rescued or re-created for the emulator.

FABL is not an authentic Atlas 1 compiler.

We have previously considered the Atlas 1 “Fixed Store”. In the real Atlas 1 to change the fixed store, it was necessary to make physical changes to the hardware. In the emulator, the fixed store is compiled from ABL source code which is provided as part of the release in the file job fixedstore.rtf.

Although the source language employed here is ABL, the job calls for the FABL compiler because the rules concerning what target addresses are permissible are different. FABL is, in point of fact, merely a different entry into the built-in ABL compiler.

When compilation is complete, and assuming that there have not been errors, the resulting image of the fixed store is saved and is used in every subsequent job. The compiled code is not, in itself, executable.

Apart from ABL and FABL all other compilers used by the emulator are stored on the so-called “Supervisor Tape” just as on the real Atlas 1. Before any of these compilers can be used, the Supervisor Tape must be made known to the emulator. Two copies of the supervisor tape are provided with the emulator viz-

SUPERVISORTAPE0
SUPERVISORTAPE1

From the menu choose Configure/Change Supervisor Tape

select which of the tapes you want to use and click .

The repertoire of available compilers can be seen by choosing View/Compilers from the menu. Greyed out names should be ignored. They are inauthentic Supervisor programs stored on the Supervisor Tape for convenience.

When using compilers from the Supervisor Tape, the procedure changes slightly. The requested compiler is loaded and the emulator pauses –

waiting for you to click the button. This allows you to investigate the action of compilers as well as your compiled programs. In the example above, the OCTAL compiler has just been loaded.

Before the first Atlas 1 had been constructed, work was going ahead on the provision of software for it. A cross-assembler was written to run on the Ferranti Mercury computer which produced output on 5-hole paper tape in the form of pairs of 8-digit octal number. each pair representing an Atlas 1 word. As soon as a substantial part of Atlas was working, a program was implemented in Atlas to read the paper tape and construct store images as the writer intended. In essence, what we are dealing with here is a loader rather than a compiler, but in Atlas terms a compiler is ’just’ a program which happens to have been stored in a convenient place.

Initially the OCTAL compiler was implemented in fixed store, but we believe that it was later moved onto the Supervisor Tape, perhaps to make room for something else. The emulator implements the OCTAL compiler on the Supervisor Ttape.

Here is a very small sample of an OCTAL program –

*00010000
04040200 00010030
43300200 00010034
44740000 00000000
00000014 50455454
57016757 62544421
E00010000
     

which is, in fact the “HELLO WORLD” program with which this tutorial started. You will notice that, in addition to the specification of the contents of store words there are two different lines. Lines starting with * specify a starting address for the content which follows. There may be several * directives. Lines starting with E give the address where the program is to start. The E directive always comes last. In addition, in a non-authentic embellishment, the emulator’s OCTAL compiler treats the / character as the start of a comment and the remainder of the line is ignored.

The program which defines the OCTAL compiler and stores it on a Supervisor Tape can be found at define octal compiler.rtf. Note that creating new compilers on Supervisor Tapes can only be done when the target tape is not the Supervisor Ttape currently in use.

RESTART is similar to OCTAL but has been enhanced to set specified values in registers as well as in the store. Its role is to restart programs which were checkpointed as described earlier. Unlike OCTAL, RESTART is not authentic.

CC is the famous Brooker-Morris COMPILER COMPILER. Rescued from contemporary program listings by Dik Leatherdale, Iain MacCallum and Bill Purvis it is intended to investigate its use, but, as yet, nothing much has been done.

The COMPILER COMPILER source code can be found at compile compiler compiler compiler.rtf and starts off by using the OCTAL compiler to read in an assembler originally compiled on Mercury. This is followed by a large Assembler program similar to but not the same as ABL and that in turn gives way to increasingly sophisticated syntactic forms until it writes itself to a Supervisor Ttape.

SPECIAL was a pseudo-compiler (actually just an ordinary program but stored on the Supervisor Tape) whose purpose was to give access to compilers stored on private tapes. The program reads the name of the desired compiler from INPUT 0 (non-alphanumeric characters are ignored) and locates it in the highest numbered tape in the job description. It then loads and enters the chosen compiler.

Note that this is not the original program, but a re-creation.

The SERVICE compiler was a series of generally useful routines which could be invoked from a list of commands in the input stream. The SERVICE compiler was lost, but a source listing has now been discovered by Bill Williams and will be transcribed into machine-readable form so that it can be added to the repertoire.

Documentation for the SERVICE compiler can be found at http://www.chilton-computing.org.uk/acl/literature/acl/p018.htm#c4p5 . Note, however, that the compiler numbers given there applied only to the Chilton site and are not the same in the emulkator.

MAGUTILS (not an original Atlas feature) fulfils a similar rôle to the SERVICE compiler but specialising in tasks which a user might wish to undertake manipulating magnetic tapes or discs – in particular, manipulating the contents of Supervisor Tapes while they are not in use.

More details here.