|
TRS80 Level I
Basic Language Reference:
The following is a chart
outlining the basic commands and parameters used in the TRS-80 Level I
Basic. This is
an excerpt of a tutorial provided by Jeff Vavasour, who has included on his site an online Basic interpreter
using
Java.. very clever. Jeff is also a prolific programmer who
has an excellent TRS-80 Model IV emulator, which I
bought commercially
from Computer News 80 many years ago. This excerpt is included
here for your enjoyment,
with the hope that it inspires you to get our
out TRS-80 and start writing code. The commands for TRS-80 Level
II
are similar but their are differences. In time you will see
those explanations here on 8bit-Micro.com.
|
|
Command |
Abbreviation |
Description |
|
LIST [n] |
L. [n] |
List program lines starting
with line n (or the first program line if n is
omitted). Up to 12 lines are listed initially. If there are more than
12 lines from line n on, the list will pause. You may scroll
through the remaining lines, one at a time, by pressing the Up Arrow
or hitting "^" (that's the carat which is Shift+6 on most keyboards).
Pressing ENTER or ESCAPE will end the list and return you to the READY
prompt. If there are only 12 lines or less, you will go to the READY
prompt automatically. |
|
RUN [n] |
R. [n] |
Start running your program
from line n. If n is omitted the program will start
at the first line. Note: variables are not
cleared when you run a program. |
|
NEW |
N. |
Erase all lines of the
current program from memory. Variables are not cleared. |
|
CONT |
C. |
Continue a program that has
been interrupted by pressing ESCAPE. The program resumes where it left
off. You cannot continue a program if you
have edited it. In that event, you'll have to restart your program by
typing
RUN. |
|
CLOAD |
CL. |
In the original Level I
BASIC, this loaded a program from casssette. |
|
CSAVE |
CS. |
In the original Level I
BASIC, this saved your program to a casssette. |
|
Statement |
Abbreviation |
Description |
|
Output and graphics commands |
|
CLS |
none |
Clears the screen and moves
the cursor back to the upper left hand corner. |
|
PRINT
[...] |
P. [...] |
Prints a message or the
contents of a variable. Can also be used to position the cursor. Full
syntax details are listed separately
below. |
|
SET(x,y) |
S.(x,y) |
Draws a pixel at the screen
coordinate (x,y) where (0,0) is the upper-left
corner, (127,0) is the upper-right corner, and (127,47) is the lower
right corner. |
|
RESET(x,y) |
R.(x,y)
or
RE.(x,y) |
Equivalent to SET, but
clears the pixel at (x,y) (i.e. sets it to black).
If used as an immediate command (i.e. at the READY prompt without
being preceeded by a line number) you should use the RE. abbreviation
instead of R. so as to avoid confusion with
RUN. |
|
Statement |
Abbreviation |
Description |
|
Setting variables |
|
LET v
= x |
L. v = x
or
v = x |
Set variable v (can
be a numeric variable A-Z, an array element A(n) or a string
A$ or B$) to the value or expression x. (e.g. "LET A=2:LET
B=1/A:LET A$=DOG") With strings, quotes are not necessary if it is the
last statement on a line and the string value does not contain a
comma. The word LET may be omitted, as it is implicit when the = sign
follows a variable name at the start of statement.. |
|
INPUT ["message";]
v[, v2][, v3][...] |
I. ["message";]
v[, v2][, v3][...] |
Optionally prints
message, then prints a question mark ("?") and waits for the user
to type a response (followed by ENTER). The user's input is then
assigned to v. (The user can type a number, a string, or an
expression. e.g. typing "1/2" in response to "INPUT A" will set A=.5.)
If multiple variables are specified, then the user should enter
multiple values, separated by commas. (e.g. responding "2,5" to "
INPUT A, B" will set A=2 and B=5.) |
|
READ
v[, v2][, v3][...] |
none |
Starting at the top of the
program, the READ statement scans the program for
DATA statements. When a
DATA value
is found, it is assigned to v. The next one is assigned to
v2 (if a second variable is specified), the third to v3
(again, if specified). Subsequent READs will pick up where the last
one left off (even if it was in the middle of a single DATA
statement). An error will occur if a READ is issued and all DATA has
already been READ. Use RESTORE to start READ from the beginning of the
program again. |
|
DATA
value1 [,value2] [,value3] |
D. value1 [,value2]
[,value3] |
Specifies data for the
READ statements.
values can be numbers or strings. (If value is a string
and the variable v in
READ v is a numeric
variable, the result will not be useful.) If the program reaches a
line containing a DATA statement, execution continues on to the next
line, passing harmlessly through the DATA statement. There can be no
statements following a DATA statement on the same line (e.g. separated
by a colon). Everything on a single line that comes after the DATA
statement is interpreted as data. |
|
RESTORE |
REST. |
Rewinds the internal pointer
so that the next READ will start looking for the first
DATA value from the
beginning of the program. |
|
Statement |
Abbreviation |
Description |
|
Flow control |
|
REM |
none |
Everything after the REM
("remark") statement on a given line is ignored. Execution continues
on to the next line after the REM statement. This is useful if you
want to insert comments, reminders or explanations into your program.
|
|
END |
E. |
Stops the program and
returns to the READY prompt. |
|
STOP |
ST. |
Makes BASIC act as if the
ESCape key had been pressed (which halts the program and displays the
command prompt). The user can manually resume execution at the next
statement after the STOP by typing
CONT at
the READY prompt. Useful for debugging. |
|
FOR v
= a TO b [STEP c] |
F. v = a
TO b [S. c] |
Indicates the start of a
counting loop. Numeric variable v (which represents a
variable A-Z or an array element A(n)) is set to the value
a. When a NEXT
statement is encountered, the value c is added to v
and compared to b. If c is positive and the new
v is less than or equal to b, execution returns to the
first line following the matching FOR statement. (If c is
negative, the program loops back if v is greater than or
equal to b.) Note: there will always be at least one pass
through the loop. Whether v is in range or not is not tested
until the NEXT
statement is encountered. Multiple FOR/NEXT statements may be nested (e.g. "FOR X=0 TO 127:FOR Y=0 TO 47:SET(X,Y):NEXT Y:NEXT X").
However, the variable NEXTs
must name the variables in the reverse order to the FORs. (e.g. in the
preceeding example, ending it with "NEXT
X:NEXT Y" would lead
to an error.) |
|
NEXT
v |
N. v |
See the
FOR
statement for details. Note: unlike some other versions of BASIC, the
variable v cannot be omitted in the NEXT statement, and forms
combining multiple variables in a single statement (e.g. "NEXT Y,X")
are not valid. Also, NEXT cannot be used as
an immediate command (i.e. typed at the READY prompt without a line
number so that it will execute immediately). In fact, N. at the READY
prompt means "NEW",
not "NEXT". |
|
IF
expression [THEN] statement |
IF expression [T.]
statement |
expression is evaluated. If it is true or non-zero, statement is
executed. statement can be any statement or combination of
statements separated by colons. e.g. IF A=21
PRINT"BLACKJACK!" or IF (R>5)*(A<=21)
THEN PRINT"PUSH".
(The latter example reads as "if R is greater than 5 and A is less
than or equal to 21". Replacing the * with a + would replace the "and"
with an "or".) As a shorthand, if statement is "GOTO l",
you can simply write the line number alone (e.g. "IF A<=21 THEN 300"
instead of "IF A<=21 THEN GOTO 300"). |
|
GOTO
l |
G. l |
Go to line l. Sets
the next statement to execute to be line l. |
|
GOSUB
l |
GOS. l |
Similar to
GOTO, but when a
RETURN is encountered, the program
will resume at the next statement following the GOSUB. (e.g. '10 GOSUB
20:PRINT"THERE":END'
followed by '20 PRINT"HELLO":RETURN'
will print "HELLO" followed by "THERE".) |
|
RETURN |
RET. |
See
GOSUB. |
|
ON
x GOTO l1[, l2][, l3][...] |
ON x G. l1[,
l2][, l3][...] |
Evaluates the numeric
expression x, truncating anything after the decimal. If the
result is 1, the program goes to line l1. If it is 2,
the program goes to l2, etc. If x is
out of range (less than 1 or greater than the number of entries in the
list), the statement is ignored. |
|
ON
x GOSUB l1[, l2][, l3][...] |
ON x GOS. l1[,
l2][, l3][...] |
Same as
ON ... GOTO except that a GOSUB l1 is executed if the result is 1,
GOSUB l2 if the result is 2, etc. |
|
Statement |
Abbreviation |
Description |
|
File input/output |
|
INPUT#
v[, v2][, v3][...] |
I.# v[, v2][,
v3][...] |
Same as
INPUT except that instead of
prompting the user, the data is read from a file. |
|
PRINT#
v [;","; v2] [;",";v3] [...] |
P.# v [;","; v2]
[;",";v3] [...] |
PRINT# is used to write
variables (strings, numeric variables and/or array elements) to a file
which will then be read back by
INPUT#. Note the format requires that
multiple variables be separated by ;","; so that a comma is written
between the elements. |
|
Function |
Abbreviation |
Description |
|
RND(x) |
R.(x) |
Returns a random whole
number between 1 and x. If x is zero it returns a
random decimal number between 0 and 1. |
|
ABS(x) |
A.(x) |
Returns the absolute value
of x (i.e. removes the negative sign if the number is
negative). |
|
INT(x) |
I.(x) |
Returns the integer portion
of a value x (i.e. removes the fraction after the decimal). |
|
MEM |
M. |
Returns a number indicating
how many bytes of memory are still free. (i.e. not taken up by your
program.) The largest array
index n which may be used in the array variable A(n)
is INT(MEM/4-1). |
|
POINT(x,y) |
P.(x,y) |
If there is a pixel set at
co-ordinate (x,y), this function returns a 1. If the
pixel at (x,y) is off (black), this function returns
a 0. Pixels are turned on or off via the
SET or
RESET statements,
respectively. |
Mathematical Operations
Used in Level I Basic
|
Operation |
Description |
|
x *
y |
Multiplies x by
y. |
|
x
/ y |
Divides x by y.
|
|
x +
y |
Returns the sum of x
and y. |
|
x
- y |
Returns the difference x
minus y. |
|
x =
y |
Returns a 1 if x
equals y. Otherwise the result is 0. |
|
x <
y |
Returns a 1 if x is
less than y. Otherwise the result is 0. |
|
x
> y |
Returns a 1 if x is
greater than y. Otherwise the result is 0. |
|
x
<= y or x =< y |
Returns a 1 if x is
less than or equal to y. Otherwise the result is 0.
|
|
x
>= y or x => y |
Returns a 1 if x is
greater than or equal to y. Otherwise the result is 0.
|
|
x
<> y or x >< y |
Returns a 1 if x
does not equal y. Otherwise the result is 0. |
Where x and y must
be either a numeric variable or an array element. Testing of a
string's equality is not supported
Level I BASIC.
Multiplication and division are
evaluated prior to addition and subtraction. And, all four of these math
operations are
evaluated before the <, =, and > comparisons. Parantheses
can be used to override this order of operations.
For example:
|
The
expression |
Evaluates as |
|
1-3/4 |
0.25 |
|
(1-3)/4 |
-0.5 |
|
1<4 |
1 |
|
0.5>=0.7 |
0 |
|
(1<4)*(0.5>=0.7) |
0 |
Note for programmers from other
languages: The IF statement will execute the statement that follows the
THEN only
if the expression evaluated is non-zero. Since a*b will
be non-zero only if a and b are both non-zero, "*" works
like a
logical AND. Similarly, since comparisons return an unsigned number
a+b will be non-zero when either of a or b
are
non-zero. So, "+" can be used as a logical OR.
Using the PRINT statement:
PRINT is a
very flexible command. At its basic level it can output a message or the
contents of a variable. For
example:
|
Statement |
What
you see on display |
|
PRINT"HELLO" |
HELLO |
A=3
PRINT A |
3 |
|
PRINT 27*6/9-40 |
-22 |
A$=TEST
PRINT A$ |
TEST |
If you end your
PRINT statement with a semicolon, the
next PRINT statement (or
INPUT statement) will
continue on
the same line, rather than starting on the next line. e.g.
PRINT"HELLO ";:PRINT"THERE"
will print the message
"HELLO THERE" on a single line.
You can also combine PRINT statements
with the semicolon. For example A=3:PRINT"A=";A
will print the message
"A= 3 ". (There is a space between the equal sign
and the 3 as that is where the sign would go if the number were
negative.)
TABs: You can also
include the function TAB(x) which will position the cursor to
column x of the current line before it
prints anything. For
example, PRINT
TAB(29);"CENTRE" will print the word CENTRE in the centre of the line.
(Each
line is 64 characters wide and x can be in the range 0-63.
If the cursor is already to the right of the requested
column, the text
will print at the cursor position. Remember, if you don't end your
PRINT statement with a
";",
subsequent PRINTs
start at the beginning of a new line).
Positioning the cursor
anywhere: There are 16 lines in the Simulator window, each
64 characters wide. You can
use the statement
PRINT AT x;... to position the
cursor anywhere on the screen prior to printing. In this case x
is a
number from 0 to 1023. 0 represents the upper-left corner, 64 the
beginning of the second line, 128 the beginning of
the third line, etc.
down to 1023 which is the lower-right corner. (Note: if you position near
the bottom there may not
be enough room for what you wish to print. If
this happens the screen will scroll.) The general formula is x =
64*r + c
where r is the row (from 0-15) and
c is the column (from 0-63).
PRINT AT 541;"MIDDLE" will print the word MIDDLE
starting 8
rows down from the top, 29 columns from the left. You can also use
PRINT AT to position
where the
INPUT prompt
is printed (e.g. "PRINT AT 541;:INPUT A$").
Colour Chart:
Below is a chart of the colour values
used by the
COL. command and returned by the
CPOINT(x,y) function. The
colours follow a pattern analogous to the CGA
graphics palette.
|
0 black* |
4 dark red
|
8 dark grey
|
12 light red
|
|
1 dark blue
|
5 dark
magenta |
9 light blue
|
13 light
magenta |
|
2 dark green
|
6 brown |
10 light
green |
14
yellow
|
|
3 dark cyan
|
7 light grey
|
11 light
cyan |
15 white
|
*Colour 0 (black) is a valid return
value for CPOINT(x,y)
but it may not be used as a parameter for the
COL.
command. If you want to draw pixels
in black, use RESET
instead of SET. If you
want to draw text in black on
another colour background, use
INVERSE.
If you want to draw black text on a black background, use spaces
instead
and pretend.
BACK TO MAIN
PAGE
|