Acorn System BASIC
Acorn System BASIC and Atom BASIC are two closely related dialects of the BASIC programming language developed by Acorn Computers for their early microcomputers like the Acorn System 3 and Acorn Atom. Developed in-house, they have a number of significant idiosyncrasies compared to most BASIC dialects of the home computer era.
In particular, the language lacked statements for many of the machine's internal functions and provided this using direct access and manipulation of memory locations using indirection operators instead of PEEK and POKE. Both also lacked floating-point support, although this could be added with an optional ROM which introduced further idiosyncrasies. System and Atom BASIC differ primarily in that Atom used the same indirection system to provide rudimentary string manipulation, which Standard lacked, and added a small number of new statements for computer graphics.
Most of these oddities were removed when the underlying system was greatly expanded to produce BBC BASIC on the Atom's successor, the BBC Micro. BBC BASIC ROMs were later offered to Atom users.
History
formed in 1978 and got its start making a series of kit-built and Eurocard-based systems starting with the Acorn System 1 in 1979. They developed Acorn System BASIC for these machines, an integer-only dialect that required only 4 KB of memory in total. The language had a number of implementation details that made it "highly non-standard."The Atom, introduced in 1980, was built from parts of the System 3 packaged onto a single board. Systems shipped standard with 2 KB of RAM and 8 KB of ROM, which included BASIC and a number of device drivers. Atom BASIC had only a few changes from the System version, adding support for string manipulation and a small number of graphics commands. The Atom was upgradable, with up to 12 KB of RAM in total and an additional 4 KB of ROM that added floating-point support. This used separate functions and operations that worked on them, indicated by the % symbol. This choice of symbol was unfortunate, as Microsoft BASIC used the percent sign to indicate integers, not floating point.
The Atom was on the market for only a short period before Acorn began development of its successor, the Proton. This was initially to be a two-processor unit. The design was still in its earliest stages when a series of events led to it being selected as the basis of the single-CPU BBC Micro. At the time, there were comments that it should definitely not use Acorn's variety of BASIC, which "virtually no other microcomputer can understand" and that "If the new language were based on the Atom's form of BASIC, it would be a disaster."
Ultimately, the BBC system did use those older Acorn-written BASIC variants, but heavily modified. The resulting BBC BASIC was much more similar to Microsoft BASIC and was later offered as an upgrade to the Atom.
Description
As the two dialects are very similar, the following will refer to Atom BASIC primarily and point out differences where they exist.Program editing
Like most BASICs of the era, Atom BASIC used a line-oriented editor with direct and indirect modes. Typing in a statement without a line number performed the operation immediately. Adding a line number instead placed those statements in the stored program. One idiosyncrasy was that while it allowed multiple statements on a single line, the separator between statements was the semicolon instead of the commonly used colon, thus requiring the user to convert that character when typing in programs for other computers.Intended for use with computer terminals, Acorn BASIC did not support a full-screen editing mode. For contrast, in Commodore BASIC, one can use the cursor keys to move upward into a program listing, make changes on-screen, and then press to enter those changes. On the Atom, which had a full-screen display, one could move upward into a listing using the cursor keys, but to edit that text, the key was pressed to copy it to the input area where it could be edited.
Another difference on the Atom was the key, which performed a system reset, potentially clearing out the program from memory. To reset this if the key was pressed by mistake, Atom BASIC added the command, which could also be used to reset an accidental. A more minor change was that used comma-separated to and from line numbers instead of the minus sign, prints out lines 20 to 40.
The language also had the ability to use line labels instead of numbers for branching. Labels consisted of a single lower-case letter typed immediately after the line number. For instance:
10s PRINT "*"
20 GOTO s
The advantage of this method is that the memory address of the statement is stored in s, meaning that the branch, a GOTO, can move directly to that line without having to search through every line in the program looking for the matching line number. Acorn also allowed any expression to be used to produce the line number for branch targets, like.
Statements
Acorn's primitives were similar to other BASICs of the era, and supported most of the elementary statements like . There are a number of common statements that are missing, notably used to store data in a program, computed branches, and for user-defined functions.To these basics, Acorn added for the construction of bottom-tested, expression-based loops. FOR loops are highly optimized by using a direct comparison between their index variable and a constant value that is set only once upon entry into the loop. Another optimization is that the address of the FOR is stored, not the line number, so when the matching NEXT is encountered the program can immediately branch back to the FOR. While FOR is suitable for many loops, when more control is needed, for instance when comparing against a more complex criterion, the IF statement may be used:
The downside to this style of loop is that the branch requires the program to be searched through for line 500, which, in a loop, normally happens many times. In large programs, this can introduce significant overhead. Using a DO for this purpose offers higher performance:
In this case, like the FOR loop, the address of the DO is stored when the loop is entered, allowing the UNTIL to return to the top of the loop immediately without having to scan through the program. Note the special case that the DO can be followed directly by another statement without the semicolon separator being required - the is not part of the, it is a separate statement.
Among the more minor additions is the statement, which paused execution until the next clock tick, every of a second. This does not wait for one entire tick, just until the next tick, which may happen immediately. calls a machine language routine, the analog of or in most dialects.
Maths, operators and functions
Acorn used 32-bit signed integers for all maths, with no standard floating-point support. To handle division, which often returns a fractional part, they added the operator to return the remainder. For instance, will return 2, while will return 1.Variable names can consist only of a single letter, A to Z. All double-letter combinations are reserved as arrays, so E was a single value, while EE was an array. All arrays required a DIM statement, it did not assume a dimension of 10 like Microsoft BASICs. At runtime, the only check performed on an array was that the index being passed in was a positive value, so one could read off into memory by passing in values larger than the dimension. It did not support multi-dimensional arrays.
Basic mathematical operations included. It also supported bitwise logic operators, with used for AND, OR and XOR, respectively. These operators perform comparisons, so returns 0. The use of the colon for OR is why the statement separator had to use the semicolon. Note that these are separate from the logical connections found in IF statements, like, which are also supported.
There were only two mathematical functions, and. ABS works as in other BASICs, returning the absolute value of a given input. RND does not, it returns a value between the -ve and +ve maximum integer values. To use this in the conventional form to return a value between 0 and a given positive value, between 0 and 10 for example, one used.
Vectors
Most BASICs of the era used PEEK and POKE to access machine specific functionality that was not built into the language itself. Acorn did not have PEEK and POKE, and used new operators to provide this functionality in an easier-to-use system. The operators were and, the former setting or returning the byte at a given location, and the latter setting or returning a 4-byte "word". For instance, common examples of PEEK in most dialects, like, could be accomplished with. Most dialects lacked the equivalent of the !. Moreover, the same syntax could be used to set the value in memory, like a POKE, for instance,.To aid in accessing data arranged in a continual form in memory, like arrays of numbers, the operators could be applied to the right-hand side of a variable. When used in this way, like, the system accessed the memory at the variable's location in memory. Any number following the operator was applied as an offset, so for instance, would return the value of the byte 100 locations after the location of A in memory.
This was often used with another Acorn-only concept, the "vector". Confusingly, these were created using the same DIM commands as an array, but applied to single-letter variables. When the DIM was encountered the system would set aside that many locations at the top of memory, and then move the memory pointer up. This left a block of memory that could then be accessed with the indirection operators. For instance:
Which will print the byte value at the 11th location in A. Likewise, one could store values in memory using the same operator applied before the variable name:
!A=123456
This will convert the decimal value 123456 from ASCII into an integer and store it in the memory locations starting at the base location for A.
To aid operation with vectors, Acorn added the pseudo-variable. When the system first started up, it pointed to the first location past the end of the program. Any DIMs were then created at the current value of TOP, and TOP was then updated to the end of the new object. It was possible to create dynamic vectors by directly manipulating TOP.