EOF# is only true if PTR# is set beyond the last byte written to the file. It will NOT be true if an attempt has been made to read from an empty block of a sparse random access file. Because of this, it is difficult to tell which records of a random access file have had data written to them. These files need to be initialised and the unused records marked as empty.
Writing to a byte beyond the current end of file updates the file length immediately, whether the record is physically written to the disk at that time or not. However, the file must be closed in order to ensure that all the data written to it is physically written to the disk.
<n-var>=EOF#(<numeric>)
OPENIN, OPENUP, OPENOUT, CLOSE#, INPUT#, READ#, BGET#, GET$#, EXT#, PTR#
You can use EOR as a logical operator or as a 'bit-by-bit' (bitwise) operator. The operands can be boolean (logical) or numeric.
Input A Input B Output 0 0 0 0 1 1 1 0 1 1 1 0
BBC BASIC does not have true boolean variables; this can lead to confusion at times (see NOT for more details).X=B EOR 4 IF A=2 EOR B=3 THEN 110
In the example below, the operands are boolean (logical) and the result of the tests (IF) A=2 and (IF) B=3 is either TRUE or FALSE.
The result of this example will be FALSE if A=2 and B=3 or A<>2 and B<>3. In other words, the answer will only be TRUE if the results of the two tests are different.
The brackets are not necessary, they have been included to make the example easier to follow.answer=(A=2 EOR B=3)
The last example uses EOR in a similar fashion to the numeric operators (+, −, etc).
Suppose X was −20, the EOR operation would be:A=X EOR 11
11111111 11111111 11111111 11101100 00000000 00000000 00000000 00001011 11111111 11111111 11111111 11100111 = -25
<n-var>=<numeric> EOR <numeric> <n-var>EOR=<numeric>
NOT, AND, OR
If there was an error in a procedure call, the line number of the calling line would be returned, not the line number of the definition.X=ERL
The number returned by ERL is the line number printed out when BBC BASIC reports an error.
See the Error Handling sub-section for more information on error handling and correction.
<n-var>=ERL
ON ERROR, REPORT, ERR
Once you have assumed responsibility for error handling using the ON ERROR statement, you can use this function to discover which error occurred.X=ERR
See the Error Handling sub-section for more information on error handling and correction.
<n-var>=ERR
ON ERROR, ERL, REPORT
Unless errors are trapped using ON ERROR this will result in the message:200 ERROR 100,"Fault"
and ERR will be set to 100. User-defined errors should normally be given error numbers in the range 100 to 179 so that they don't conflict with the built-in error codes. However, if you specify an error number of zero BBC BASIC will treat it as a fatal error, i.e. it will not be trapped by the ON ERROR statement and will cause the program to end immediately.Fault at line 200
Note that the error string is held in a temporary buffer, which will be overwritten if an INPUT, CALL or READ statement is executed, or if BBC BASIC returns to immediate mode. This means you should be careful when accessing the error string using REPORT or REPORT$; if necessary copy it into a conventional string variable first.
ERROR is also used in the ON ERROR, ON ERROR LOCAL and RESTORE ERROR statements.
ERROR <numeric>,<string>
ON ERROR <stmt>{:<stmt>}
ON ERROR LOCAL <stmt>{:<stmt>}
ON ERROR OFF
RESTORE ERROR
ON ERROR, ON ERROR LOCAL, ERL, ERR, REPORT, RESTORE
EVAL |
EV. |
X=EVAL("X^Q+Y^P")
X=EVAL"A$+B$"
X$=EVAL(A$)
In effect, you pass the string to BBC BASIC's evaluation program
and say 'work this out'.
You can use this function to accept and evaluate an expression, such as a mathematical equation, whilst the program is running. You could, for instance, use it in a 'calculator' program to accept and evaluate the calculation you wished to perform. Another use would be in a graph plotting program to accept the mathematical equation you wished to plot.
The example below is a 'bare bones' calculator program which evaluates the expression typed in by the user.
You can only use EVAL to work out functions (like SIN, COS, etc). It won't execute statements like MODE 0, PRINT, etc. Note that EVAL may fail if you use it to evaluate a structure member, since the 'dot' after the structure name may cause it to be interpreted as an abbreviated keyword.PRINT "This program evaluates the expression" PRINT "you type in and prints the answer" REPEAT INPUT "Enter an expression" exp$ IF exp$<>"END" PRINT EVAL exp$ UNTIL exp$="END" END
<n-var>=EVAL(<string>) <s-var>=EVAL(<string>)
STR$, VAL
EXIT |
EX. |
EXIT FOR causes execution to continue after the matching NEXT statement, EXIT REPEAT causes execution to continue after the matching UNTIL statement and EXIT WHILE causes execution to continue after the matching ENDWHILE statement. Typically you would use EXIT when a situation occurs which necessitates leaving the loop 'part way through':
In the case of EXIT FOR an optional loop variable can be specified, causing execution to continue after the NEXT statement which matches that variable:FOR I% = start% TO finish% ... IF bool% THEN EXIT FOR ... NEXT I% REPEAT ... IF bool% THEN EXIT REPEAT ... UNTIL condition% WHILE condition% ... IF bool% THEN EXIT WHILE ... ENDWHILE
FOR I% = start% TO finish%
FOR J% = first% TO last%
...
IF bool% THEN EXIT FOR I%
...
NEXT
NEXT
REM Execution continues here
You can EXIT from a loop even when inside a nested loop of a different kind:
REPEAT
FOR J% = first% TO last%
...
IF bool% THEN EXIT REPEAT
...
NEXT
UNTIL FALSE
REM Execution continues here
EXIT is not compatible with the use of non-standard FOR...NEXT constructs such as
'popping' an inner loop or listing multiple loop variables after NEXT. When EXIT is
used, every FOR must have a matching NEXT.
EXIT FOR [<n-var>] EXIT REPEAT EXIT WHILE
FOR, REPEAT, WHILE
This function can be used as the 'anti-log' of a natural logarithm. Logarithms are 'traditionally' used for multiplication (by adding the logarithms) and division (by subtracting the logarithms). For example,Y=EXP(Z)
will calculate 2.5*2 by adding their natural logarithms and print the answer.log1=LN(2.5) log2=LN(2) log3=log1+log2 answer=EXP(log3) PRINT answer
<n-var>=EXP(<numeric>)
LN, LOG
In the case of a sparse random-access file, the value returned is the complete file length from byte zero to the last byte written. This may well be greater than the actual amount of data on the disk, but it is the amount of disk space allocated to the file by the filing system.length=EXT#f_num
If you want to write extra data at the end of an existing file, you should open the file with OPENUP and then set the file pointer to the end of the existing data:
The file must have been opened before EXT# can be used to find its length.PTR#channel = EXT#channel
EXT# is also used when accessing a communications port (e.g. a serial port). It returns the number of characters which have been received, but not yet read. To prevent blocking you should attempt to read (with BGET#) no more than this number of characters.
(BBC BASIC for Windows only)
EXT# may also be used on the left of the equals sign to set the file's length:
EXT#channel = newlength
<n-var>=EXT#(<numeric>) EXT#(<numeric>)=<numeric>
OPENIN, OPENUP, OPENOUT, CLOSE#, PRINT#, INPUT#, READ#, BPUT#, BGET#, GET$#, PTR#, EOF#
FALSE |
FA. |
You can use FALSE in a REPEAT....UNTIL loop to make the loop repeat for ever. Consider the following example.flag=FALSE ... IF flag ...
Since 'terminator' will never be zero, the result of the test 'terminator=0' will always be FALSE. Thus, the following example has the same effect as the previous one.terminator=10 REPEAT PRINT "An endless loop" UNTIL terminator=0
Similarly, since FALSE=0, the following example will also have the same effect, but its meaning is less clear.REPEAT PRINT "An endless loop" UNTIL FALSE
See the keyword AND for logical tests and their results.REPEAT PRINT "An endless loop" UNTIL 0
<n-var>=FALSE
TRUE, EOR, OR, AND, NOT
The operation may appear to fail if the graphics background colour is not available as a 'solid' colour, with the current display settings, and has therefore been approximated by 'dithering'.
FILL x,y is equivalent to PLOT 133,x,y
FILL BY x,y is equivalent to PLOT 129,x,y
FILL is also used with the CIRCLE, ELLIPSE and RECTANGLE statements to indicate that a filled (solid) shape should be drawn, or that a block move rather than a block copy is required.
FILL 400,400
FILL <numeric>,<numeric> FILL BY <numeric>,<numeric> CIRCLE FILL <numeric>,<numeric>,<numeric> ELLIPSE FILL <numeric>,<numeric>,<numeric>,<numeric> RECTANGLE FILL <numeric>,<numeric>,<numeric>,<numeric> [TO <numeric>,<numeric>]
BY, CIRCLE, ELLIPSE, GCOL, RECTANGLE
A function may take any number of parameters of any type (or none), and may return a string or numeric result. It does not have to be defined before it is used.
A function definition is terminated by '=' used at the beginning of a statement.
The first two examples below are single line function definitions and the third is a multi-line definition:
Functions are re-entrant and the parameters (arguments) are normally passed by value. The keyword RETURN can be used in the function definition to specify that a parameter should instead be passed by reference. Arrays and structures are always passed by reference.DEF FN_mean(Q1,Q2,Q3,Q4)=(Q1+Q2+Q3+Q4)/4 DEF FN_fact(N):IF N<2 THEN =1 ELSE =N*FN_fact(N-1) DEF FN_reverse(A$) LOCAL B$,Z% FOR Z%=1 TO LEN(A$) B$=MID$(A$,Z%,1)+B$ NEXT =B$
The following function sets the print control variable to the parameter passed and returns a null string. It may be used in a PRINT command to change the print control variable (@%) within a print list.
Functions have to return a result, but the value returned by this function is a null string. Consequently, its only effect is to change the print control variable. Thus the PRINT statementDEF FN_pformat(N):@%=N:=""
will print X in G9z10 format and Y in F2z10 format. See the keyword PRINT for print format details.PRINT FN_pformat(&90A) X FN_pformat(&2020A) Y
Single-line functions can be placed anywhere within your program. Multi-line functions must be placed where they will not be executed 'out of sequence', this usually means at the end of the program after the END statement. See the Procedures and functions sub-section for more information.
FN may alternatively be followed by a numeric value contained in parentheses. This causes the function pointed to by the specified value to be called (an indirect call):
See the Indirect procedure and function calls sub-section for more information.fptr% = ^FN_mean() mean = FN(fptr%)(a, b, c, d)
<n-var>|<s-var>=FN<name>[(<exp>{,<exp>})]
<n-var>|<s-var>=FN(<numeric>)[(<exp>{,<exp>})]
DEF FN<name>[(<n-var>|<s-var>{,<n-var>|<s-var>})]
DEF, ENDPROC, LOCAL, PRIVATE, PROC, RETURN
FOR |
F. |
The FOR...NEXT loop is a way of repeating a section of program a set number of times. For example, the two program segments below perform identically, but the second is easier to understand.FOR temperature%=0 TO 9 FOR A(2,3,1)=9 TO 1 STEP -0.3
You must not exit a FOR...NEXT loop with a GOTO (see the sub-section on Program Flow Control for more details). You can force a premature end to the loop with the EXIT statement:10 start=4: end=20: step=2 20 counter=start 30 PRINT counter," ",counter^2 40 counter=counter+step 50 IF counter<=end THEN 30 60 ... 10 start=4: end=20: step=2 20 FOR counter=start TO end STEP step 30 PRINT counter," ",counter^2 40 NEXT 50 ...
It is not necessary to declare the loop variable as an integer type in order to take advantage of fast integer arithmetic. If it is an integer, then fast integer arithmetic is used automatically.FOR I=1 TO 20 X=A^I IF X>1000 THEN EXIT FOR PRINT I,X NEXT
Any numeric assignable item may be used as the control variable. In particular, a byte variable (?X) may act as the control variable and only one byte of memory will be used. See the Indirection sub-section for details of the indirection operators.
Because a single stack is used, you cannot use a FOR...NEXT loop to set array elements to LOCAL in a procedure or function.FOR ?X=0 TO 16: PRINT ~?X: NEXT FOR !X=0 TO 16 STEP 4: PRINT ~!X: NEXT
FOR <n-var>=<numeric> TO <numeric> [STEP <numeric>]
TO, STEP, NEXT, EXIT
GCOL |
GC. |
GCOL sets the graphics foreground or background colour, and optionally specifies how the colour is to be plotted on the screen. It can be plotted directly, ANDed, ORed or Exclusive-ORed with the colour already there, or the existing colour can be inverted.GCOL colour GCOL mode,colour
When GCOL is followed by one value the graphics foreground or background colour is set, and the plotting mode is set to 'plot'. If the value is less than 128, the graphics foreground colour is set to that value. If the number is 128 or greater, the graphics background colour is set to value−128. There are up to 16 logical colours (numbered 0 to 15), but the number available varies with the mode; see the section on graphics colours for details.
When GCOL is followed by two values the first determines the plotting mode and the second the graphics foreground or background colour. The plotting modes are as follows:
| mode=0 | Plot the colour specified. |
| mode=1 | OR the specified colour with the colour that is already there. |
| mode=2 | AND the specified colour with the colour that is already there. |
| mode=3 | Exclusive-OR the specified colour with the colour that is already there. |
| mode=4 | Invert the colour that is already there. |
See the Compatibility limitations section for important notes on the use of these plotting modes.GCOL 1 : REM sets the graphics foreground colour to 1 GCOL 130 : REM sets the graphics background colour to 2 GCOL 3,4 : REM sets the mode to EOR and the colour to 4
GCOL n is equivalent to VDU 18,0,n
GCOL m,n is equivalent to VDU 18,m,n.
Generally, you will not notice a change in the graphics background colour until you clear the graphics screen with a CLG command.
GCOL [<numeric>,]<numeric>
CLS, CLG, MODE, COLOUR, PLOT
GET and GET$ wait for a 'key' (character) to be present in the keyboard buffer and then return the ASCII value of that key or a string (length=1) containing the character of the key. If there are any characters in the keyboard buffer when a GET or GET$ is issued, then the function will return immediately. See the keyword INKEY for a way of emptying the keyboard buffer before issuing a GET.N=GET N$=GET$
GET and GET$ do not echo the pressed key to the screen. If you want to display the character for the pressed key, you must PRINT or VDU it.
If the function and cursor keys have been redefined using the *KEY command, pressing them will load the keyboard buffer with their currently defined character string. Since GET and GET$ remove characters from the keyboard buffer, one character will be returned every time a GET is issued. A single GET will return the first character and leave the rest in the keyboard buffer.
You can use GET and GET$ whenever you want your program to wait for a reply before continuing. For example, you may wish to display several screens of instructions and allow the user to decide when he has read each screen.
Note that using GET prevents any events, for example ON CLOSE, from being processed until you press a key. For that reason it is often better to use INKEY instead:REM First screen of instructions CLS PRINT ....... PRINT ....... PRINT "Press any key to continue "; temp=GET REM Second screen of instructions CLS PRINT ....... etc
The default values returned by the function and cursor control keys are listed below:PRINT "Press any key to continue "; REPEAT temp=INKEY(1):UNTIL temp>0
| 8 | Backspace | 9 | Tab | 13 | Enter | ||
| 128 | Ctrl/ |
129 | Ctrl/ |
130 | Home | 131 | End |
| 132 | PgUp | 133 | PgDn | 134 | Insert | 135 | Delete |
| 136 | |
137 | |
138 | |
139 | |
| 140 | Mouse wheel down | 141 | Mouse wheel up | ||||
| 145 | F1 | 161 | Shift/F1 | 177 | Ctrl/F1 | 193 | Alt/F1 |
| 146 | F2 | 162 | Shift/F2 | 178 | Ctrl/F2 | 194 | Alt/F2 |
| 147 | F3 | 163 | Shift/F3 | 179 | Ctrl/F3 | 195 | Alt/F3 |
| 148 | F4 | 164 | Shift/F4 | 180 | Ctrl/F4 | 196 | Alt/F4+ |
| 149 | F5 | 165 | Shift/F5 | 181 | Ctrl/F5 | 197 | Alt/F5 |
| 150 | F6 | 166 | Shift/F6 | 182 | Ctrl/F6 | 198 | Alt/F6 |
| 151 | F7 | 167 | Shift/F7 | 183 | Ctrl/F7 | 199 | Alt/F7 |
| 152 | F8 | 168 | Shift/F8 | 184 | Ctrl/F8 | 200 | Alt/F8 |
| 153 | F9 | 169 | Shift/F9 | 185 | Ctrl/F9 | 201 | Alt/F9 |
| 154 | F10 | 170 | Shift/F10 | 186 | Ctrl/F10 | 202 | Alt/F10 |
| 155 | F11* | 171 | Shift/F11 | 187 | Ctrl/F11 | 203 | Alt/F11 |
| 156 | F12* | 172 | Shift/F12 | 188 | Ctrl/F12 | 204 | Alt/F12 |
| 157 | F13* | 173 | Shift/F13 | 189 | Ctrl/F13 | 205 | Alt/F13 |
| 158 | F14* | 174 | Shift/F14 | 190 | Ctrl/F14 | 206 | Alt/F14 |
| 159 | F15* | 175 | Shift/F15 | 191 | Ctrl/F15 | 207 | Alt/F15 |
* these codes are also generated from the following key combinations:
| 155 | Shift/Tab |
| 156 | Ctrl/Home |
| 157 | Ctrl/End |
| 158 | Ctrl/PgUp |
| 159 | Ctrl/PgDn |
+note that Alt/F4 normally closes the window so does not actually return the code listed. You can make Alt/F4 return code 196 by using the ON CLOSE statement, but beware that this will also prevent you closing the window by clicking on the close button.
The mouse wheel codes (140 and 141) require Windows™ 98 or later.
If you would prefer the Delete key to produce the ASCII code DEL (127) instead of its default value (135) you can achieve that using *KEY as follows:
(that is, the vertical line or pipe character followed by a question mark).*KEY 23 |?
GET(X,Y) returns the character at text coordinates X,Y as an ASCII code. GET$(X,Y) returns the character at text coordinates X,Y as a string. The coordinates are with respect to the current text viewport. If the coordinates are outside the viewport GET(X,Y) returns −1 and GET$(X,Y) returns an empty string.N=GET(X,Y) N$=GET$(X,Y)
In UTF-8 mode GET$(X,Y) returns a string of length 1, 2 or 3 bytes, depending on the position of the character within the Basic Multilingual Plane.
Note that GET(X,Y) and GET$(X,Y) do not work reliably if the text was written using a proportional-spaced font, or in a mixture of different fonts, or if the font has changed since the text was written.
GET$ can also be used to read a string from a file. GET$ differs from INPUT# and READ# in that it reads a string terminated by carriage-return (&0D), line-feed (&0A) or NUL (&00) - you cannot tell what the terminator actually was. It also differs in that if a terminator character is not found within 65535 bytes, it returns a string of length 65535 containing the data read up to this point (BBC BASIC for Windows v5.95a only). By contrast, INPUT# and READ# return an empty string in these circumstances, and the data read from the file is discarded. GET$# is therefore more useful if the format of the file is uncertain.A$=GET$#file_channel
GET$ may optionally be used with the qualifier BY (to specify how many bytes to read from the file) or TO (to specify the terminator character). These override the normal CR, LF or NUL terminators:
The terminator character is specified as its ASCII code, for example to specify a comma terminator use TO 44, TO &2C or TO ASC(","). If you add &100 to the value (e.g. TO &12C) the specified terminator will be recognised in addition to (rather than instead of) the normal CR and LF terminators.dest$=GET$#file_channel BY bytecount% dest$=GET$#file_channel TO termchar%
If you add &8000 to the value (e.g. TO &802C) CR (carriage return) will be recognised as a terminator in addition to the specified character (in this example a comma). However LF will not be recognised as a terminator.
<n-var> = GET <s-var> = GET$ <n-var> = GET(<numeric>,<numeric>) <s-var> = GET$(<numeric>,<numeric>) <s-var> = GET$#<numeric> <s-var> = GET$#<numeric> BY <numeric> <s-var> = GET$#<numeric> TO <numeric>
INKEY, INKEY$, INPUT#, READ#, OPENIN, OPENOUT, OPENUP
The only limit placed on the depth of nesting is the room available for the stack.GOSUB 400 GOSUB (4*answer+6) GOSUB (mysub)
You may calculate the line number. However, if you do, the program should not be renumbered. A calculated value must be placed in brackets.
Very often you need to use the same group of program instructions at several different places within your program. It is tedious and wasteful to repeat this group of instructions every time you wish to use them. You can separate this group of instructions into a small sub-program. This sub-program is called a subroutine. The subroutine can be 'called' by the main program every time it is needed by using the GOSUB statement. At the end of the subroutine, the RETURN statement causes the program to return to the statement after the GOSUB statement.
GOSUB <l-num> GOSUB (<numeric>)
RETURN, ON, PROC
GOTO |
G. |
You should never GOTO a line which is outside the current FOR...NEXT, REPEAT...UNTIL or WHILE...ENDWHILE loop.GOTO 100 GOTO (X*10) GOTO (mydest)
If a calculated value is used, the program should not be renumbered. A calculated value must be placed in brackets.
The use of GOTO is deprecated. Uninhibited use will make your programs almost impossible to understand (and hence, debug). It is always possible to find an alternative to using GOTO, and invariably your programs will be improved as a result.
GOTO <l-num> GOTO (<numeric>)
GOSUB, ON
By default, HIMEM is set at slightly less than 2 Mbytes above LOMEM. If this is insufficient for your program and data, you can raise HIMEM (subject to there being sufficient memory in your computer). This is an important difference from other versions of BBC BASIC, in which you must never raise HIMEM above its initial value. Note that INSTALLed libraries are loaded immediately above HIMEM, so if you do raise HIMEM above the value it had when the first library was loaded, all libraries will be removed.
If you need to raise HIMEM don't be tempted to set it to an absolute value (memory addresses are allocated by the Operating System and vary from session to session). Instead always set it relative to the value of PAGE, LOMEM or TOP. For best performance, set HIMEM to an exact multiple of four; you can achieve that by ANDing it with -4 (&FFFFFFFC).
If you need to reserve an area of memory which will not be affected by CHAIN or CLEAR (for example to pass data between programs) you can lower HIMEM from its initial value. The area of memory between the new value of HIMEM and the old value of HIMEM (−1) will not be used by BBC BASIC (except when the INSTALL statement loads the first library).
HIMEM must not be changed within a subroutine, procedure or function; in a FOR ... NEXT, REPEAT ... UNTIL, or WHILE ... ENDWHILE loop nor within a multi-line IF ... ENDIF clause. If you want to change HIMEM, it is better to do so early in your program.
HIMEM = PAGE+10000000 HIMEM = (LOMEM+10000000) AND -4 HIMEM = HIMEM-40
HIMEM=<numeric> <n-var>=HIMEM
LOMEM, PAGE, TOP
The IF statement is the primary decision making statement. The testable condition (A<C, etc) is evaluated, and converted to an integer if necessary. If the value is non-zero the rest of the line (up to the ELSE clause if there is one) is executed. If the value is zero, the rest of the line is ignored, unless there is an ELSE clause in which case execution continues after the ELSE.IF length=5 THEN 110 IF A<C OR A>D GOTO 110 IF A>C AND C>=D THEN GOTO 110 ELSE PRINT "BBC" IF A>Q PRINT"IT IS GREATER":A=1:GOTO 120
The above examples will print "Under 21" if the value of 'age' is less than 21, and do nothing otherwise.IF age<21 THEN PRINT "Under 21" flag=age<21 IF flag THEN PRINT "Under 21"
The above examples will print "Under 21" if the value of 'age' is less than 21, and "21 or over" otherwise.IF age<21 THEN PRINT "Under 21" ELSE PRINT "21 or over" flag=age<21 IF flag THEN PRINT "Under 21" ELSE PRINT "21 or over"
The keyword THEN is optional in most examples of the single-line IF statement. The exceptions are when THEN is followed immediately by a destination line number, by a pseudo-variable (e.g. TIME) or by an end-of-function (=). However, THEN is mandatory for the multi-line IF statement.
A multi-line IF clause is begun by an IF statement which has the keyword THEN as the very last thing on the line (it cannot even be followed by a REMark). It is ended by an ENDIF statement, which must be the first thing on the line. If the integer numeric expression after IF is non-zero, the statements up to the ENDIF (or ELSE clause if present) are executed. If the expression evaluates to zero the statements after ELSE are executed, or if there is no ELSE clause execution continues after the ENDIF statement.IF length=5 THEN PRINT "length is 5" ELSE PRINT "length is not 5" ENDIF
There may be any number of lines between the IF ... THEN statement and the ENDIF statement. Multi-line IF ... ENDIF clauses may be nested.
You can cascade multiple IF ... ENDIF clauses to test a number of different alternatives:
IF x=3 THEN
PRINT "x is 3"
ELSE IF x=4 THEN
PRINT "x is 4"
ELSE IF x=5 THEN
PRINT "x is 5"
ELSE
PRINT "x is not 3 or 4 or 5"
ENDIF
ENDIF
ENDIF
but in this situation a CASE statement would be a better
choice.
IF <t-cond> THEN <stmt>{:<stmt>} [ELSE <stmt>{:<stmt>}]
IF <t-cond> GOTO <l-num> [ELSE <l-num>]
IF <t-cond> THEN <l-num> [ELSE <l-num>]
IF <t-cond> THEN
THEN, ELSE, ENDIF
INKEY or INKEY$ is followed by a numeric argument. If this is zero or positive it indicates the maximum time to wait for a keypress (in units of 10ms). If it is negative it indicates which key should be tested.
The INKEY function returns the ASCII value of the key pressed. The INKEY$ function returns a string (length=1) containing the character corresponding to the key pressed. The values returned by the function and other special keys are tabulated under GET/GET$.
If the function and cursor keys have been redefined using the *KEY command, pressing them will load the keyboard buffer with their currently defined character string. Since INKEY and INKEY$ remove characters from the keyboard buffer, one character will be returned every time an INKEY is issued. A single INKEY will return the first character and leave the rest in the keyboard buffer.key=INKEY(num) N=INKEY(0) N$=INKEY$(100)
INKEY can be used to 'empty' the keyboard buffer. You can do this with the following program line:
REPEAT UNTIL INKEY(0)=-1
The numeric values corresponding to the different keys are as follows (note that these values are as compatible as possible with the BBC Micro and the Acorn Archimedes, allowing for the differences between their keyboards and the PC's keyboard).
| A | −66 | N | −86 | 1 | −49 | [ | −57 | f1 | −114 |
| B | −101 | O | −55 | 2 | −50 | ] | −89 | f2 | −115 |
| C | −83 | P | −56 | 3 | −18 | ; | −88 | f3 | −116 |
| D | −51 | Q | −17 | 4 | −19 | ' | −80 | f4 | −21 |
| E | −35 | R | −52 | 5 | −20 | # | −91 | f5 | −117 |
| F | −68 | S | −82 | 6 | −53 | , | −103 | f6 | −118 |
| G | −84 | T | −36 | 7 | −37 | . | −104 | f7 | −23 |
| H | −85 | U | −54 | 8 | −22 | / | −105 | f8 | −119 |
| I | −38 | V | −100 | 9 | −39 | \ | −121 | f9 | −120 |
| J | −70 | W | −34 | 0 | −40 | Tab | −97 | f10 | −31 |
| K | −71 | X | −67 | − | −24 | Bksp | −48 | f11 | −29 |
| L | −87 | Y | −69 | = | −94 | Enter | −74 | f12 | −30 |
| M | −102 | Z | −98 | ` | −46 | Space | −99 | Esc | −113 |
| Insert | −62 | Home | −63 | PgUp | −64 | | −26 | | −122 |
| Delete | −90 | End | −106 | PgDn | −79 | | −58 | | −42 |
| Shift | −1 | Ctrl | −2 | Alt | −3 | Caps | −65 | L-shift | −4 |
| R-shift | −7 | L-ctrl | −5 | R-ctrl | −8 | L-alt | −6 | R-alt | −9 |
| Numeric keypad: | |||||||||
|---|---|---|---|---|---|---|---|---|---|
| 0 | −107 | 1 | −108 | 2 | −125 | 3 | −109 | 4 | −123 |
| 5 | −124 | 6 | −27 | 7 | −28 | 8 | −43 | 9 | −44 |
| . | −77 | + | −59 | − | −60 | * | −92 | / | −75 |
| Enter | −61 | Num | −78 | ||||||
Note that the above table corresponds to the standard UK keyboard layout. The US keyboard differs slightly:
| ` | −80 | ' | −91 |
The mouse buttons can be tested with −10 (left) −11 (middle) and −12 (right)
Important note: On some Operating Systems INKEY with a negative argument works whether or not your program has the input focus. This can occasionally be useful, but often you will prefer to detect a key being pressed only when the user is working with your program. In that case you can check for input focus.IF INKEY(-99) PRINT "Space bar pressed"
In BBC BASIC for Windows INKEY(-256) returns the value ASC("W"), i.e. 87; in BBC BASIC for SDL 2.0 it returns either ASC("S"), i.e. 83, or ASC("s"), i.e. 115.
<n-var>=INKEY(<numeric>) <s-var>=INKEY$(<numeric>)
GET, GET$, MOUSE, WAIT
If the items are not immediately preceded by a printable prompt string (even if null) then a '?' will be printed as a prompt. If the variable is not separated from the prompt string by a comma, the '?' is not printed. In other words: no comma - no question mark.INPUT A,B,C,D$,"WHO ARE YOU",W$,"NAME"R$
Items A, B, C, D$ in the above example can have their answers returned on one to four lines, separate items being separated by commas. Extra items will be ignored.
Then WHO ARE YOU? is printed (the question mark comes from the comma) and W$ is input, then NAME is printed and R$ is input (no comma - no '? ').
When the <Enter> key is pressed to complete an entry, a new-line is generated. BBC BASIC has no facility for suppressing this new-line, but the TAB function can be used to reposition the cursor. For example,
will position the cursor at column 0 of line 5 and print the prompt Name ?. After the name has been entered the cursor will be positioned at column 20 on the same line and Age ? will be printed. When the age has been entered the cursor will move to the next line.INPUT TAB(0,5) "Name ? " N$,TAB(20,5) "Age ? " A
The statement
is exactly equivalent toINPUT A
Leading spaces will be removed from the input line, but not trailing spaces. If the input string is not completely numeric, it will make the best it can of what it is given. If the first character is not numeric, 0 will be returned. Neither of these two cases will produce an error indication. Consequently, your program will not abort back to the command mode if a bad number is input. You may use the EVAL function to convert a string input to a numeric and report an error if the string is not a proper number or you can include your own validation checks.INPUT A$: A=VAL(A$)
Strings in quoted form are taken as they are, with a possible error occurring for a missing closing quote.INPUT A$ A=EVAL(A$)
A semicolon following a prompt string is an acceptable alternative to a comma.
See the input editing section for details of the editing facilities available when entering data in response to an INPUT statement.
INPUT [TAB(X[,Y])][SPC(<numeric>)]['][<s-const>[,|;]]
<n-var>|<s-var>{,<n-var>|<s-var>}
INPUT LINE, INPUT#, GET, INKEY
INPUT LINE A$
INPUT LINE[TAB(X[,Y])][SPC(<numeric>)]['][<s-const>[,|;]]
<s-var>{,<s-var>}
INPUT
It is possible to read past the end-of-file without an error being reported. You should usually include some form of check for the end of the file.INPUT #E,A,B,C,D$,E$,F$ INPUT #chnl,aux$
READ# is synonymous with INPUT#. When INPUT# and READ# are used to read strings, they look for a carriage-return terminator (&0D), which is what is written with PRINT#. If the string was written by another program and is terminated with a line-feed character (&0A), then use GET$# instead.
The format of data files differs according to the *FLOAT mode in effect at the time (in *FLOAT 40 mode numeric values are written as 5 bytes, in *FLOAT 64 mode they are written as 8 bytes and in *FLOAT 80 mode they are written as 10 bytes). You must ensure that when numeric values are read with INPUT# (or READ#) the same *FLOAT mode is in effect as when the values were written.
The format of data files is different from files created by Acorn versions of BBC BASIC. If you want to read from an Acorn format data file you can use the following function, which takes the file channel number as a parameter and returns a numeric or string value as appropriate (this works only in the default *FLOAT 40 mode):
See the Disk files section for more details and numerous examples of the use of INPUT#.DEF FNacorn(F%):LOCAL I%:I%=BGET#F% IF I%=&40 ?(^I%+3)=BGET#F%:?(^I%+2)=BGET#F%:?(^I%+1)=BGET#F%:?(^I%)=BGET#F%:=I% IF I%=0 I%=BGET#F%:LOCAL A$:WHILE I% A$=CHR$BGET#F%+A$:I% -= 1:ENDWHILE:=A$ LOCAL N:INPUT #F%,N:IF ?(^N+4)=0 THEN =0 ELSE =N/2
INPUT #<numeric>,<n-var>|<s-var>{,<n-var>|<s-var>}
INPUT, OPENIN, OPENUP, OPENOUT, CLOSE#, PRINT#, READ#, BPUT#, BGET#, GET$#, EXT#, PTR#, EOF#
Because the procedures and functions do not form part of your program the size of its file is reduced, and if a bug is found in one of the functions it can be corrected by updating the library file without having to modify each of the programs from which it is called.
You can INSTALL as many library files at the same time as you like, subject to there being sufficient memory. These libraries remain resident until the BASIC program's window is closed (they are not cleared by a CHAIN statement). If two or more libraries contain a procedure or function of the same name, the one used is that in the last library loaded.
The libraries are loaded above HIMEM so if you raise HIMEM above the value it had when the first library was INSTALLed, all the libraries will be removed from memory.
A library file is a standard BBC BASIC internal-format (tokenised) program file except that it should normally contain only procedure and function definitions. Line numbers and labels are not recognised in library files, therefore the GOTO and GOSUB statements cannot be used, and the only variant of the RESTORE statement which is useful is the RESTORE +n form used in conjunction with LOCAL DATA and RESTORE DATA.
You should normally prefix the filename with either @lib$ (for standard libraries) or @dir$ (for libraries specific to your program) so that the file will be loaded from the correct location irrespective of the current directory setting. See the Library routines section for details of the supplied libraries.
INSTALL checks to see if the library is already loaded, and if so it does nothing. Note that a case-sensitive comparison of the supplied path/filename is performed, so the same library being specified differently will not be detected.INSTALL @lib$+"arraylib" INSTALL @dir$+"mylib"
INSTALL <string>
HIMEM, FN, PROC
The first string is searched for any occurrence of the second string.
There must not be any spaces between INSTR and the opening bracket.
You can use this function for validation purposes. If you wished to test A$ to see if was one of the set 'FRED BERT JIM JOHN', you could use the following:X=INSTR(A$,B$) position=INSTR(find_in$,look_for$) Y=INSTR(A$,B$,Z%) :REM START AT POSITION Z%
The character used to separate the items in the set must be excluded from the characters possible in A$. One way to do this is to make the separator an unusual character, say CHR$(127).set$="FRED BERT JIM JOHN" IF INSTR(set$,A$) PROC_valid ELSE PROC_invalid
z$=CHR$(127) set$="FRED"+z$+"BERT"+z$+"JIM"+z$+"JOHN"
<n-var>=INSTR(<string>,<string>[,<numeric>])
LEFT$, MID$, RIGHT$, LEN
This function converts a real number (one with a decimal part) to the nearest integer (whole number) less than or equal to the number supplied. Thus,X=INT(Y) INT(99.8) = 99 INT(-12) = -12 INT(-12.1) = -13
gives 14, whereasINT(14.56)
gives −15.INT(-14.5)
Note: INT truncates towards minus infinity but assignment to an integer variable truncates towards zero. Thus:
prints -15 and -14 respectively.x% = INT(-14.5) PRINT x% x% = -14.5 PRINT x%
<n-var>=INT<numeric>
None
There must not be any spaces between LEFT$ and the opening bracket.
For example,newstring$=LEFT$(A$,num) A$=LEFT$(A$,2) A$=LEFT$(RIGHT$(A$,3),2) LEFT$(A$,3) = B$
would printname$="BBC BASIC" FOR i=3 TO 9 PRINT LEFT$(name$,i) NEXT END
LEFT$(A$,0) returns an empty string; LEFT$(A$,-1) returns the original string unmodified.BBC BBC BBC B BBC BA BBC BAS BBC BASI BBC BASIC
When using LEFT$ on the left of an equals sign, and the expression to the right of the equals sign evaluates to a string with fewer characters than the specified sub-string length, only that number of characters is changed. For example:
will set A$ equal to "ZZC BASIC". Although the sub-string length is set to three, only two characters are actually modified since that is the length of the string "ZZ".A$ = "BBC BASIC" LEFT$(A$,3) = "ZZ"
LEFT$(A$) is shorthand for LEFT$(A$,LENA$-1), in other words it returns or sets all but the last character of A$.
<s-var>=LEFT$(<string>[,<numeric>]) LEFT$(<s-var>[,<numeric>])=<string>
RIGHT$, MID$, LEN, INSTR
This function 'counts' the number of characters in a string. For example,X=LEN"fred" X=LENA$ X=LEN(A$+B$)
length=LEN("BBC BASIC")
would set 'length' to 9.
LEN is often used with a FOR....NEXT loop to 'work down' a string doing something with each letter in the string. For example, the following program looks at each character in a string and checks that it is a valid hexadecimal digit.
valid$="0123456789ABCDEF"
REPEAT
INPUT "Type in a HEX number" hex$
flag=TRUE
FOR i=1 TO LEN(hex$)
IF INSTR(valid$,MID$(hex$,i,1))=0 flag=FALSE
NEXT
IF NOT flag THEN PRINT "Bad HEX"
UNTIL flag
<n-var>=LEN(<string>)
LEFT$, MID$, RIGHT$, INSTR
LET was mandatory in early versions of BASIC. Its use emphasised that when we write
we don't mean to state that X equals X+4 - it can't be, but rather 'let X become equal to what it was plus 4':X=X+4
Most modern versions of BASIC allow you to drop the 'LET' statement. However, if you are writing a program for a novice, the use of LET makes it more understandable.LET X=X+4
[LET] <var>=<exp>
None
This will draw a straight line from the point 100,200 to the point 300,400.LINE 100,200,300,400
LINE x1,y1,x2,y2 is equivalent to MOVE x1,y1 : DRAW x2,y2
The keyword LINE is also used in the INPUT LINE statement. LINE INPUT is synonymous with INPUT LINE.
LINE <numeric>,<numeric>,<numeric>,<numeric>
LINE INPUT [TAB(X[,Y])][SPC(<numeric>)]['][<s-const>[,|;]]
<s-var>{,<s-var>}
DRAW, INPUT, MOVE, PLOT
This function gives the logarithm to the base 'e' of its argument. The 'natural' number, 'e', is approximately 2.71828183.X=LN(Y)
Logarithms are 'traditionally' used for multiplication (by adding the logarithms) and division (by subtracting the logarithms). For example,
will calculate 2.5*2 by adding their natural logarithms and print the answer.log1=LN(2.5) log2=LN(2) log3=log1+log2 answer=EXP(log3) PRINT answer
<n-var>=LN<numeric>
LOG, EXP
LOCAL saves the value(s) of the specified variable(s) on the stack, and initialises the variables to zero (in the case of numeric variables) or null (in the case of string variables). The original values are restored from the stack on exit from the function or procedure (i.e. at '=' or ENDPROC). The variables need not have been previously declared.
An entire array may be made LOCAL, following which it is in an undimensioned state. Before the local array can be used within the function or procedure it must be dimensioned using a DIM statement. The new dimensions can be the same as or different from those of a global array with the same name. LOCAL arrays are allocated on the stack, and are freed when the function/procedure is exited.
Similarly an entire structure may be made LOCAL, following which it is in an undeclared state. Before the local structure can be used within the function or procedure it must be declared using a DIM statement. The new format (number and type of members) can be the same as or different from that of a global structure with the same name. LOCAL structures are allocated on the stack, and are freed when the function/procedure is exited.
See also PRIVATE which is similar to LOCAL except that the variables hold their values from one call of the function/procedure to the next, rather than being initialised to zero/null each time.
If a function or a procedure is used recursively, the LOCAL variables will be preserved at each level of recursion.LOCAL A$,X,Y%,items()
LOCAL DATA RESTORE +1 DATA "Here", "is", "some", "local", "data" READ A$, B$, C$, D$, E$ RESTORE DATA
LOCAL is also used in the ON CLOSE LOCAL, ON ERROR LOCAL, ON MOUSE LOCAL, ON MOVE LOCAL, ON SYS LOCAL, ON TIME LOCAL, DIM LOCAL and RESTORE LOCAL statements.
LOCAL <n-var>|<s-var>|<array()>{,<n-var>|<s-var>|<array()>}
LOCAL <struct{}>{,<struct{}>}
LOCAL DATA
DEF, DIM, ENDPROC, FN, ON, PRIVATE, PROC
This function calculates the common (base 10) logarithm of its argument. Inverse logarithms (anti-logs) can be calculated by raising 10 to the power of the logarithm. For example, if x=LOG(y) then y=10^x.X = LOG(Y)
Logarithms are 'traditionally' used for multiplication (by adding the logarithms) and division (by subtracting the logarithms). For example,
log1=LOG(2.5) log2=LOG(2) log3=log1+log2 answer=10^log3 PRINT answer
<n-var>=LOG<numeric>
LN, EXP
Normally, dynamic variables are stored in memory immediately after your program (see the section entitled Format of data in memory). You can change the address where BBC BASIC starts to store these variables by changing LOMEM.LOMEM = LOMEM+100 PRINT ~LOMEM :REM The ~ makes it print in HEX.
USE WITH CARE. Changing LOMEM in the middle of a program causes BBC BASIC to lose track of all the variables you are using.
LOMEM=<numeric> <n-var>=LOMEM
HIMEM, TOP, PAGE
|
CONTINUE
|
