Atlas Autocode
Atlas Autocode (AA) was a programming language developed around 1965 at
Manchester University for the Atlas Computer. It was developed by Tony Brooker and Derrick Morris as an improvement on the
ALGOL programming languages, removing some of
Algol's poorer features such as passing parameters by name. It featured explicitly typed variables, subroutines and functions.
The AA compiler generated range-checking for array accesses, and the language allowed an array to have dimensions that were
determined at run-time (i.e. you could declare an array as integer array Thing (i:j), where
i and j were calculated values). Atlas Autocode included a complex data type which
would support complex numbers (for example, the square root of -1), a feature which was
dropped when the language later morphed into the Edinburgh IMP programming language. (Imp
was an extension of AA and was notable for being used to write the EMAS
operating system.)
Keywords in AA were represented as being underlined, however for the sake of easy typing it was possible to strop keywords by placing a "%" sign in front of them, for example the keyword
endofprogramme could be typed as %end %of %programme or %endofprogramme
There were no reserved words in the language. In the statement if token=if then result =
token, there is both a keyword if and a variable named if.
Because of this keyword stropping, it was possible for AA to allow spaces in variable names, such as integer
previous value. Spaces were not significant and were removed prior to parsing in a trivial pre-lexing stage called "line
reconstruction". What the compiler would see in the above example would be
"iftoken=ifthenresult=token".
The syntax for expressions was very close to mathematical standards and allowed implicit multiplication such as z = 3x +
y as an alternative to the more common z = x * 3 + y.
Atlas Autocode's syntax was influenced by the output device which the author had available, a Friden Flexowriter. Consequently it allowed symbols like "½" and superscripts for "i2". The flexowriter supported overstriking and therefore AA did as well - up to three characters could be overstruck as a single symbol. For example the character set had no "↑" symbol, so exponentiation was an overstrike of "|" and "*". (The underlining of keywords mentioned above could also be done using overstriking.) The language is described in detail in the Atlas Autocode Reference Manual.
When AA was ported to the KDF9 computer, the character set was changed to ISO and that compiler has actually been recovered from an old paper tape by the Edinburgh Computer History Project and is available online, as is a high-quality scan of the original Atlas Autocode manual.
Atlas Autocode's second-greatest claim to fame (after being the progenitor of Imp and EMAS) was that it was the original "Compiler Compiler" of which "Yacc" was a later derivative. A variant of the AA compiler included run-time support for a top-down recursive descent parser. The style of parser used in the Compiler Compiler was in use continuously at Edinburgh from the 60's until almost the turn of the millennium.
Other Autocodes were developed for the Titan (computer) (a prototype Atlas 2) at Cambridge and the Ferranti Mercury.
External links
- Atlas Autocode Reference Manual
- Programming In Atlas Autocode - Edinburgh University Computer Unit Report #1 (1965) (PDF 1.2 format - you may need to right-click and save first, depending on your browser and version of Adobe reader)
This entry is from Wikipedia, the leading user-contributed encyclopedia. It may not have been reviewed by professional editors (see full disclaimer)
