View source for Acorn System BASIC

{{Short description|Dialect of the BASIC programming language}}
{{Infobox programming language
| name = Acorn System BASIC
| logo = 
| file_ext = 
| paradigm = 
| year = {{Start date and age|1979}}
| designer =
| developer = [[Acorn Computers]]
| latest_release_version = 
| latest_release_date = 
| latest_test_version = 
| latest_test_date = 
| typing = 
| implementations = 
| dialects = Atom BASIC
| influenced_by = 
| influenced = [[BBC BASIC]]
| operating_system = 
| license = Proprietary
| website = 
| wikibooks = 
}}
'''Acorn System BASIC''' and '''Atom BASIC''' are two closely related dialects of the [[BASIC programming language]] developed by [[Acorn Computers]] for their early [[microcomputer]]s like the [[Acorn Eurocard systems#System 3|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 arithmetic|floating-point]] support, although this could be added with an optional [[read-only memory|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==
[[File:Hermann Hauser using Acorn Atom 2012.jpg|thumb|[[Hermann Hauser]] uses Atom BASIC at the BBC Micro 30th anniversary.]]

[[Acorn Computers]] formed in 1978 and got its start making a series of kit-built and [[Eurocard (printed circuit board)|Eurocard]]-based systems starting with the [[Acorn System 1]] in 1979. They developed Acorn System BASIC for these machines,{{sfn|Gazzard|2016|p=22}} an integer-only dialect that required only 4&nbsp;KB of memory in total.{{sfn|Oddy}} The language had a number of implementation details that made it "highly non-standard."{{sfn|Lien|1981|p=425}}

The [[Acorn Atom|Atom]], introduced in 1980, was built from parts of the System 3 packaged onto a single board. Systems shipped standard with 2&nbsp;KB of RAM and 8&nbsp;KB of ROM, which included BASIC and a number of [[device driver]]s. 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&nbsp;KB of RAM in total and an additional 4&nbsp;KB of ROM that added [[floating-point arithmetic|floating-point]] support. This used separate functions and operations that worked on them, indicated by the % symbol.{{sfn|Lien|1981|p=425}} This choice of symbol was unfortunate, as [[Microsoft BASIC]] used the percent sign to indicate integers, not floating point.{{sfn|Lien|1981|p=396}}

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]].{{sfn|Gazzard|2016|p=22}} 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."{{sfn|BBC|1981|p=662}}

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.{{sfn|Fruits|1982|p=11}}

==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 (immediate) 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{{sfn|Johnson Davies|1979|p=14}} 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 terminal]]s, Acorn BASIC did not support a full-screen editing mode. For contrast, in [[Commodore BASIC]] (and many other microcomputer dialects), one can use the cursor keys to move upward into a program listing, make changes on-screen, and then press {{key|Return}} 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|Copy}} key was pressed to copy it to the input area where it could be edited.{{sfn|Johnson Davies|1979|p=65}}

Another difference on the Atom was the {{key|Break}} 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 {{code|OLD}} command, which could also be used to reset an accidental {{code|NEW}}. A more minor change was that {{code|LIST}} used comma-separated to and from line numbers instead of the minus sign, {{code|LIST 20,40}} prints out lines 20 to 40.{{sfn|Johnson Davies|1979|p=7}}

The language also had the ability to use line labels instead of numbers for [[Branch (computer science)|branching]]. Labels consisted of a single lower-case letter typed immediately after the line number. For instance:{{sfn|Johnson Davies|1979|p=25}}

 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.{{sfn|Johnson Davies|1979|p=25}} Acorn also allowed any expression to be used to produce the line number for branch targets, like {{code|GOSUB 500+(A*10)}}.{{sfn|Johnson Davies|1979|p=26}}

===Statements===
Acorn's primitives were similar to other BASICs of the era, and supported most of the elementary statements like {{mono|CLEAR, DIM, END, [[For loop|FOR..TO..STEP..NEXT]], [[GOSUB]], [[GOTO]], [[Conditional (programming)|IF..THEN]], INPUT, (optional) LET, LIST, LOAD, PRINT, [[Comment (computer programming)|REM]], [[Return statement|RETURN]], RUN, SAVE, STOP}}.{{sfn|Johnson Davies|1979|pp=3-4}} There are a number of common statements that are missing, notably {{mono|DATA, READ, RESTORE}} used to store data in a program, {{mono|ON..GOSUB, ON..GOTO}} [[Computed GOTO and Assigned GOTO|computed branches]], and {{mono|DEF FN}} for user-defined functions.{{efn|A good source for what was already considered the standard for BASICs of the microcomputer era is the introduction to ''[[BASIC Computer Games]]'', which introduces the statements it uses and speaks of exceptions to "normal BASIC".<ref>{{cite book |title=BASIC Computer Games |first=David |last=Ahl |date=1978 |publisher=Workman |page=XII}}</ref>}}

To these basics, Acorn added {{code|DO..UNTIL}} 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:

 500 A=A+1
 510 REM additional statements here
 600 IF A>10 AND B>100 THEN 500

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:

 500 DO A=A+1
 510 REM additional statements here
 600 UNTIL A>10 AND B>100

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.{{sfn|Johnson Davies|1979|p=37}} Note the special case that the DO can be followed directly by another statement without the semicolon separator being required - the {{code|A{{=}}A+1}} is not part of the {{code|DO}}, it is a separate statement.{{sfn|Johnson Davies|1979|p=35}}

Among the more minor additions is the {{code|WAIT}} statement, which paused execution until the next clock tick, every {{frac|60}} of a second. This does not wait for one entire tick, just until the ''next'' tick, which may happen immediately.{{sfn|Johnson Davies|1979|p=37}} {{code|LINK}} calls a [[machine language]] routine,{{sfn|Lien|1981|p=427}} the analog of {{code|CALL}} or {{code|SYS}} in most dialects.{{sfn|Lien|1981|p=43}}

===Math, operators and functions===
Acorn used 32-bit signed [[integer]]s for all math,{{sfn|Johnson Davies|1979|p=67}} with no standard [[floating-point arithmetic|floating-point]] support. To handle division, which often returns a fractional part, they added the {{code|%}} operator to return the remainder. For instance, {{code|PRINT 7/3}} will return 2, while {{code|PRINT 7%3}} will return 1.{{sfn|Johnson Davies|1979|p=11}}

Variable names can consist only of a single letter, A to Z.{{sfn|Johnson Davies|1979|p=12}} 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,{{sfn|Johnson Davies|1979|p=45}} it did not assume a dimension of 10 like [[Microsoft BASIC]]s. 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.{{sfn|Johnson Davies|1979|p=50}} It did not support multi-dimensional arrays.{{sfn|Johnson Davies|1979|p=51}}

Basic math operations included {{mono|+, -, *, /, %}}. It also supported bitwise logic operators, with {{mono|&, \, :}} used for AND, OR and XOR, respectively. These operators perform comparisons, so {{code|1 & 0}} returns 0. The use of the colon for OR{{efn|Likely because it looks like a vertical bar, which is used in most math texts for OR.}} is why the statement separator had to use the semicolon.{{sfn|Johnson Davies|1979|p=15}} Note that these are separate from the logical connections found in IF statements, like {{code|IF A{{=}}1 AND B{{=}}0 THEN...}}, which are also supported.{{sfn|Johnson Davies|1979|p=30}}

There were only two math functions, {{mono|ABS}} and {{mono|RND}}. 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 {{code|ABS(RND)%11}}.{{sfn|Johnson Davies|1979|p=24}}

===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 {{code|?}} and {{code|!}}, the former setting or returning the byte at a given location, and the latter setting or returning a 4-byte "word".{{sfn|Lien|1981|p=426}} For instance, common examples of PEEK in most dialects, like {{code|PRINT PEEK(4000)}}, could be accomplished with {{code|PRINT ?4000}}.{{sfn|Johnson Davies|1979|p=53}} Most dialects lacked the equivalent of the !.{{efn|Various advanced dialects like [[Turbo-BASIC XL]] included commands like {{code|DPEEK}} for "double peek", returning a 16-bit value. These are similar in concept to !.<ref>{{cite book |url=http://ftp.pigwa.net/stuff/collections/Atari%20books/Turbo-BASIC%20XL%20-%20Expanded%20Documentation.pdf |first= Ron |last=Fetzer |title=Expanded Turbo-BASIC XL Documentation |date=1985}}</ref>}} Moreover, the same syntax could be used to set the value in memory, like a POKE, for instance, {{code|?4000{{=}}200}}.{{sfn|Johnson Davies|1979|p=53}}

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 {{code|A?}}, 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, {{code|A?100}} would return the value of the byte 100 locations after the location of A in memory.{{sfn|Johnson Davies|1979|p=53}}

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:{{sfn|Johnson Davies|1979|p=53}}

 10 DIM A(100)
 20 PRINT A?10

Which will print the byte value at the 11th location in A (all accesses are zero-indexed).{{sfn|Johnson Davies|1979|p=53}} 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.{{sfn|Lien|1981|p=426}}

To aid operation with vectors, Acorn added the pseudo-variable {{code|TOP}}. 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.{{sfn|Johnson Davies|1979|p=46}}

===Strings===
Atom BASIC added string support but did not support string variables nor did it have the concept of a string as an atomic type. Instead, the vector system was used to manipulate string data in memory, as [[ASCII]] values.{{sfn|Johnson Davies|1979|p=53}} To aid this usage, the {{code|$}} operator converted in-memory values to their ASCII values. This operator continued reading data from memory until it encountered a return, and when writing data to memory, always added a return at the end.{{sfn|Johnson Davies|1979|p=58}} So while {{code|PRINT ?A}} would print the single value of the byte at A's location in memory as a number, {{code|PRINT $A}} would read the values starting at that location and print it as a string.{{sfn|Johnson Davies|1979|p=58}} For instance:

 10 DIM A(12)
 {{typo|20 $}}A="HELLO, WORLD"
 30 PRINT $A

This code may appear very similar to the use of strings in other dialects, although the location of the $ relative to the variable name changes. It is especially similar to those dialects that required a DIM on all strings, like [[HP Time-Shared BASIC]] or [[Atari BASIC]]. Internally, the operation is very different. In those dialects, A and A$ are two different variables and the $ is, in effect, part of the name. In Acorn, A and $A they are the same variable, and the $ is applying a unary operation to that variable. This also means one can use arrays for strings, like {{code|$AA(10)}}, which converts the value in AA(10) to a string.{{sfn|Lien|1981|p=425}}

This concept allows individual characters to be accessed using vector notation. For instance, {{code|A?5}} would return the ASCII value of the 5th character, 79 for O in this case, while {{code|PRINT $A?5}} would output "O".{{sfn|Johnson Davies|1979|p=59}} There is no way to extract a substring in a single operation, one has to loop over the characters and move them one-by-one. Concatenation is possible by assigning one variable to the end of another, for instance, {{code|$A+LEN(A){{=}}$B}} copies the string B to the end of A.{{sfn|Johnson Davies|1979|p=61}}

The language has only two string functions, {{code|LEN}} which looks for the trailing return character and returned the length, and {{code|CH}} to return the ASCII value of a character. CH has an odd format with no parens, so {{code|CH"A"}} would return 65.{{sfn|Johnson Davies|1979|p=59}} It is otherwise similar to the more common {{code|ASC}} seen in other dialects.{{sfn|Lien|1981|p=45}}

Another new operator was {{code|#}}, which converted a numeric value into a [[hexadecimal]] string. Like $, this could be used anywhere to perform the conversion. For instance, {{code|A{{=}}#4000}} sets the value of A to the decimal value 16384, the location of the screen memory. This was often combined with the $ operator to allow strings to contain unprintable characters, like the "cursor up" character.{{sfn|Johnson Davies|1979|p=65}}

===Floating point===
Floating-point support could be added with the additional 4&nbsp;KB ROM expansion. This used an expanded 40-bit word size, 32 bits of signed mantissa followed by an 8-bit exponent.{{sfn|Johnson Davies|1979|p=162}} This meant the system needed some way to distinguish the data when reading and writing from memory, which was handled in a fashion similar to the string operator, using the {{code|%}} prefix:{{sfn|Johnson Davies|1979|p=162}}

  %A=123.45

As the code was contained in a separate 4&nbsp;KB ROM, it did not modify existing statements like PRINT. Instead, an entirely new set of statements was introduced, including {{mono|FDIM, FIF, FINPUT, FPRINT, FUNITL}}. This means, for instance, that one cannot {{code|IF A{{=}}B}} if the values are floating point, one must instead {{code|FIF A{{=}}B THEN...}}. An integer value can be converted to float using the {{code|FLT}}, and float to integer using the float operator, %.{{sfn|Lien|1981|p=426}}

The ROM also included a much larger variety of math functions, including {{mono|ABS, ACS, ASN, ATN, COS, DEG, EXP, FLT, HTN, LOG, PI, RAD, SGN, SIN, SQR, STR, TAN, VAL}}.{{sfn|Johnson Davies|1979|p=161}} {{code|STR}} converted a floating-point number into a string, as was the case for {{code|STR$}} in other dialects, but in this case, the string was written to memory and the function returned the address where it was stored. As the string required storage long enough to hold it, this was often accomplished using TOP. For instance:

  STR PI, TOP
  PRINT $TOP
  TOP=TOP-LEN(TOP)

This converts the value of the pseudo-variable PI to a string starting at memory location TOP, prints the string using $TOP, and then abandons that memory.{{sfn|Johnson Davies|1979|p=163}}

===Input/output===
{{code|PRINT}} and {{code|INPUT}} mostly worked as in other dialects. One oddity came about because the colon and semicolon were already used for other purposes, leaving only the comma to separate fields. To print values with no spaces between them, the values were listed with a space character between them, like {{code|PRINT A B C}}, a format that was also allowed on many other dialects although rarely used. This alone would not cause numbers to be printed in compact format, because they are normally printed with spaces on the right to make each one 8 characters wide This could be adjusted by changing the value in the {{code|@}} pseudo-variable.{{sfn|Johnson Davies|1979|p=13}} A newline was printed with a single quote, {{code|PRINT "HELLO" ' "WORLD"}}.{{sfn|Lien|1981|p=426}} {{code|COUNT}} returns the cursor column, similar to {{code|POS}} in most dialects.{{sfn|Lien|1981|p=73}}

The default storage device for the Atom was a [[compact cassette]] system. Each file was stored as a series of blocks, each of which contained a header with the filename.{{sfn|Johnson Davies|1979|p=10}} Files saved with {{code|SAVE THISFILE}} could be read back in with {{code|LOAD THISFILE}}, whilst {{code|*CAT}} listed the names of the files on the cassette as it read past their headers.{{sfn|Johnson Davies|1979|p=9}}

Arbitrary data could be opened for reading using {{code|FIN}} or writing with {{code|FOUT}}, both of which returned a numeric [[file handle]]. Files were closed with {{code|SHUT}}. Data was read or written in numeric format using {{code|GET, PUT}}, as single bytes with {{code|BGET, BPUT}}, and as strings using {{code|SGET, SPUT}}. The {{code|EXT}} returned the length of the file, while {{code|PTR}} returned or set the current pointer in the file, {{sfn|Lien|1981|p=427}} the number of bytes read or written so far.{{sfn|Johnson Davies|1979|p=151}} If the floating-point ROM was present, it added {{code|FGET, FPUT}}.{{sfn|Johnson Davies|1979|p=161}}

For instance:

 A=FOUT"AFILE"
 DO BPUT A,88; WAIT; WAIT; WAIT; WAIT; UNTIL 0

Will use the {{code|BPUT}} to write a series of bytes, 88s, until the user presses {{keypress|Escape}} to stop the program. They can then be read back in (after manually rewinding the tape) using:{{sfn|Johnson Davies|1979|p=8}}

 A=FIN"AFILE"
 DO PRINT $BGET A; UNTIL 0

The dollar sign tells the system to convert the incoming binary data to string format, so in this case, the output will be a series of X's, not 88's.{{sfn|Johnson Davies|1979|p=8}} It might seem that SGET could be used instead of BGET, but this would attempt to continue reading from the file until it saw a return character, which in this example had not been written.{{sfn|Johnson Davies|1979|p=152}}

===Graphics support===
The Atom had rudimentary [[bitmap|bitmap graphic]]s and Atom BASIC added a number of commands to support it. {{code|CLEAR}} cleared the screen, {{code|MOVE}} moved the graphical cursor to the given X,Y location, and {{code|DRAW}} drew a line from the current location to the provided X,Y.{{sfn|Johnson Davies|1979|p=28}}

The floating-point ROM also included support for colour graphics with the addition of the {{code|COLOUR}} statement. Calling COLOUR with a parameter 0 through 3, sets the subsequent output to that colour. On a black-and-white display, the colours were shown as shades of grey.{{sfn|Johnson Davies|1979|p=167}}

==Notes==
{{notelist}}

==References==
===Citations===
{{reflist|15em}}

===Bibliography===
* {{cite book
 |first=David |last=Johnson Davies
 |title=Atomic Theory and Practice
 |publisher=Acorn Computers
 |date=1979
}}
* {{cite book
 |title=Acorn System BASIC
 |url=http://81.174.146.201/acorn/Acorn%20System%20Software/System%20BASIC/Acorn%20System%20Basic%2028-7-1980%20[7].pdf
 |ref=CITEREFOddy
}}
* {{cite book
 |first=David |last=Lien
 |title=The BASIC Handbook: Encyclopedia of the BASIC Computer Language
 |publisher=Compusoft Publishing
 |date=1981
 |url=https://archive.org/details/basichandbookenc00lientexts
}}
* {{cite book
 |first=Alison |last=Gazzard
 |title=Now the Chips are Down: The BBC Micro
 |publisher=MIT Press
 |date=2016
 |isbn=9780262034036
 |url=https://books.google.com/books?id=EpyZCwAAQBAJ
}} 
* {{cite magazine
 |title=The BBC runs into basic language problems
 |magazine=New Scientist
 |date=12 March 1981
 |url=https://books.google.com/books?id=x57gHRJjGC4C&pg=PA662
 |ref=CITEREFBBC1981
}}
* {{cite magazine
 |title=Acorn to offer fruits in U.S.
 |magazine=InfoWorld 
 |date=14 June 1982
 |url=https://books.google.com/books?id=YDAEAAAAMBAJ&pg=PA11
 |ref=CITEREFFruits1982
}}

{{BASIC}}

{{DEFAULTSORT:Atom Basic}}
[[Category:Acorn Computers]]
[[Category:BASIC interpreters]]
[[Category:BASIC programming language family]]