Southampton BASIC System

Language characteristics

In common with many early implementations of BASIC, SOBS needed lines to have line numbers, both to allow a user to add new lines to the program in the desired place and also as targets for GOTO and GOSUB statements. A RENUMBER facility was available to allow for sections of the code to be renumbered, by default in increments of 10, to allow more space in the middle of a program.

Other than line numbers, all numeric values were represented internally as floating point.

Statements

The language had relatively few statements by comparison with modern programming languages:

Statement	Purpose
`DATA`	Stored data for `READ`ing into variables at runtime
`DIM var(size)...`	Dimension an array. One-, two- and three-dimensional arrays were supported.
`END`	Halt execution of the program.
`FOR var=start TO end [STEP incr]`	Perform a set of statements repeatedly for varying values of var
`GOSUB line`	Call a subroutine at a given line number; flow would return to the next statement when a `RETURN` was executed.
`GOTO line`	Unconditional branch to a given line number.
`IF expr THEN line [ELSE line]`	Conditionally branch. The `THEN` and `ELSE` parts could only give line numbers to go to.
`INPUT var`	Prompt the user for input data
`LET var=expr`	Assign a value to a variable. Unlike many modern dialects of BASIC, `LET` was not an optional word.
`NEXT var`	Perform the next iteration of a `FOR` loop.
`PRINT`	Output to the Teletype
`READ var...`	Read data from `DATA` statements into variables
`REM`	Short for `REM`ark, this allowed for a comment to be placed on a line
`RESTORE [line]`	Reset the `READ` pointer in order to re-read `DATA`
`RETURN`	Return to the line following a `GOSUB`.

Note in particular the lack of a WHILE-like statement; FOR was the only looping construct available to programmers.

Variables

Variable names for numeric values were either a single letter, or a single letter followed by a single numeric digit, thus allowing for 286 discreet variables in total. Strings were supported; variable names for them had the same restriction but were followed by a pound (£) symbol.

Functions

A limited number of numeric functions were provided, all of which took one numeric parameter:

Function	Function( $x$ ) returned
`SIN`	$\sin x$
`COS`	$\cos x$
`ATN`	$\arctan x$
`SQR`	${\sqrt {x}}$
`LOG`	$\log x$
`EXP`	$e^{x}$
`INT`	The largest integer not greater than $x$
`SGN`	−1, 0, or 1, depending on whether $x$ was less than, equal to, or greater than zero
`ABS`	$-x$ if $x$ was negative, otherwise $x$

Support for strings was more limited, with only one function, LEN, which returned the length of the string parameter. Sub-strings were supported with square brackets, so A£[2,3] referred to the sub-string of the string A£ from the 2nd character to the 3rd character inclusive, so

 10 LET A£ = "FOO"
 20 PRINT A£[2,3]

would print OO

This syntax was also supported on the left-hand side of an assignment, so

 10 LET A£ = "FOO"
 20 LET A£[2,2] = "BAR"
 30 PRINT A£

would print FBARO

Arrays

Support for handling arrays of data was relatively strong, with MAT statements able to read an entire array from DATA statements, and perform useful matrix operations such as matrix addition, matrix subtraction, matrix multiplication, and finding the inverse matrix for a square matrix.

Example:

 10 DIM A(3,3)
 20 MAT READ A
 30 DATA 1,1,2,1,0,2,0,2,1
 40 DIM B(3,3)
 50 MAT READ B
 60 DATA 0,0,1,0,1,0,1,0,0
 70 DIM C(3,3),D(3,3)
 80 MAT C=A*B
 90 MAT D=INV(C)
 100 MAT PRINT D,

`A` is read from the first `DATA` statement	${\begin{pmatrix}1&1&2\\1&0&2\\0&2&1\end{pmatrix}}$
`B` is read from the second `DATA` statement	${\begin{pmatrix}0&0&1\\0&1&0\\1&0&0\end{pmatrix}}$
`C` is calculated by multiplying `A` and `B`	${\begin{pmatrix}2&1&1\\2&0&1\\1&2&0\end{pmatrix}}$
`D` is calculated as the inverse of `C`	${\begin{pmatrix}2&2&1\\1&-1&0\\4&-3&-2\end{pmatrix}}$

The output would be

2              2              1
1              -1             0
4              -3             -2

Debugging

SOBS had primitive debugging capabilities, limited mostly to the TRACE statement. TRACE ON would cause the interpreter to print each line number as it was executed.

References

↑ Rees, M.J.; Oppenheimer, A.W. (21 January 1977). "SOBS - an incremental BASIC system". Software. Wiley InterScience. doi:10.1002/spe.4380070508. Retrieved 18 May 2009.

Dialects of the BASIC programming language (list)

Classic	Altair BASIC Applesoft BASIC Atari BASIC Atari Microsoft BASIC Atari ST BASIC BASICA BASIC A+ BASIC Programming BASIC XE BASIC XL Casio BASIC Chipmunk Basic Color BASIC Commodore BASIC Extended Color BASIC Dartmouth BASIC Disk Extended Color BASIC Family BASIC GFA BASIC GW-BASIC HP BASIC for OpenVMS HP Time-Shared BASIC IBM BASIC Integer BASIC Locomotive BASIC Mallard BASIC Microsoft BASIC MSX BASIC Pure Basic Rocky Mountain BASIC S'-BASIC (Tandy, Casio, Sharp Pocket Computers) ScriptBasic Sinclair BASIC Southampton BASIC System STOS BASIC TI BASIC (TI 99/4A) TI-BASIC (calculators) TI Extended BASIC (aka XBasic) Tiny BASIC Turbo-Basic XL Tymshare SUPER BASIC UBASIC Vilnius BASIC XBasic

Procedure-oriented	AmigaBASIC AMOS BASIC ASIC BBC BASIC Beta BASIC DarkBASIC FreeBASIC FutureBASIC GFA BASIC GLBasic Liberty BASIC Microsoft Small Basic PowerBASIC PureBasic QBasic QB64 QuickBASIC SmallBASIC SuperBASIC ThinBasic True BASIC Turbo Basic XBasic Xblite Basic4ppc Visual Test

With object extensions	AutoIt Basic For Qt (KBasic) BlitzMax Chipmunk Basic FreeBASIC Gambas GLBasic Monkey X OpenOffice Basic PowerBASIC ProvideX RapidQ REALbasic Run BASIC Visual Basic Visual Basic .NET Xojo

For mobile devices	Basic4android Basic4ppc GLBasic NS Basic

Microsoft	Microsoft BASIC MBASIC IBM BASIC/BASICA GW-BASIC QuickBASIC QBasic VBScript Visual Basic VBA Visual Basic .NET Embedded Visual Basic VB 5 for Microsoft Excel 5.0 VSTO VSTA WordBASIC TRS-80 Basics (Level I, Level II, Level III) Microsoft Small Basic

Third-party VB-like	Gambas Hummingbird Basic LotusScript WinWrapBasic

This article is issued from Wikipedia - version of the 4/10/2016. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.