0,0 → 1,1540 |
|
|
|
|
|
|
|
|
|
|
|
I T T Y B I T T Y C O M P U T E R S |
|
TINY BASIC User Manual |
|
|
|
|
|
|
|
Congratulations! You have received the first of what we hope |
is a long line of low cost software for hobby computers. We are |
operating on a low margin basis, and hope to make a profit on |
volume. Please help us to stay in business by respecting the |
Copyright notices on the software and documentation. |
If you are in a hurry to try TINY BASIC, Appendix C will tell |
you how to get on the air. Then come back and read the rest of this |
manual --- most of it is useful information. |
|
The TINY BASIC interpreter program has been extensively tested |
for errors ("bugs"), but it would be foolish to claim of any program |
that it is guaranteed bug-free. This program does come with a |
"Limited Warranty" in that any errors discovered will be corrected in |
the first 90 days. Catastrophic bugs will be corrected by |
automatically mailing out corrected versions to all direct mail |
customers and local dealers. Minor bugs will be corrected by |
request. In any case this warranty is limited to replacement of the |
Program Tape and/or documentation, and no liability for consequential |
damages is implied. |
If you think you have found a bug, make a listing of the |
program that demonstrates the bug, together with the run input and |
output. Indicate on the listing what you think is wrong and what |
version number you are running and your serial number (on the tape |
leader). Mail this to: |
|
ITTY BITTY COMPUTERS |
P.0. Box 6539 |
San Jose, CA 95150 |
|
We will try to be responsive to your needs. |
|
|
---------- |
(C) Copyright 1976 by Tom Pittman. All rights reserved. |
|
"Itty Bitty" is a Trademark of the ITTY BITTY COMPUTERS Company. |
|
|
1 |
|
TINY BASIC was conceived by the dragons at the People's |
Computer Company (PCC), a non-profit corporation in Menlo Park CA. |
and its implementation defined by Dennis Allison and others in the |
PCC newspaper and an offshoot newsletter. The implementation of this |
program follows the philosophy defined there. The reader is referred |
to PCC v.4 Nos 1-3 for a discussion of the inner workings of this |
software. |
In keeping with the "small is good" philosophy, TINY BASIC |
employs the two level interpreter approach (with its consequent speed |
cost) so that the whole system occupies only 2K of program memory |
(exclusive of user program; some versions are slightly larger). |
With 1K of additional RAM small but useful user programs (50 lines or |
less) may be accommodated. A system with 4K of RAM can contain the |
interpreter and about 100 lines of user program. |
|
TINY BASIC is offered in several versions for each processor. |
One is designed to be used with an arbitrary operating system, and |
executes out of low memory (e.g. 0100-08FF for the 6800). The other |
versions are configured for unusual memory requirements of particular |
operating systems. All are "clean" programs, in that they will |
execute properly from protected memory (such as PROM). Direct |
addressing is used for interpreter variables as much as possible, so |
memory Page 00 is largely dedicated. In all cases the user programs |
are placed at the end of that part of lower memory used by TINY, and |
they may occupy all the remaining contiguous memory. Appendix D is a |
a summary of the important low-memory addresses. |
TINY BASIC is designed to be I/O independent, with all input |
and output funneled through three jumps placed near the beginning of |
the program. In the non-standard versions these are preset for the |
particular operating system I/O, so the discussion to follow is |
primarily concerned with the standard versions. For this |
discussion, it is assumed that the interpreter begins at hex address |
0100, though the remarks may be applied to other versions with an |
appropriate offset. |
Location 0106 is a JMP to a subroutine to read one ASCII |
character from the console/terminal. Location 0109 is a JMP to a |
subroutine to type or display one ASCII character on the |
console/terminal. In both cases the character is in the A |
accumulator, but the subroutine need not preserve the contents of the |
other registers. It is assumed that the character input routine will |
simultaneously display each character as it is input; if this is not |
the case, the JMP instruction in location 0106 may be converted to a |
JSR, so that each character input flows through the output subroutine |
(which in this case must preserve A) before being fed to TINY. |
Users with terminals using Baudot or some other non-ASCII code should |
perform the character conversion in the Input and Output subroutines. |
If your console is a CRT and/or you have no need to output or |
display extra pad characters with each Carriage Return and Linefeed, |
you may intercept these in the output routine to bypass their |
display. Each input prompt by TINY is followed by an "X-ON" |
character (ASCII DC1) with the sign bit set to 1 (all other |
characters except rubout are output with the sign bit set to 0) so |
these are also readily detected and deleted from the output stream. |
Appendix C shows how to perform these tests. |
A third subroutine provided by you is optional, and gives TINY |
|
|
2 |
|
a means to test for the BREAK condition in your system. Appendix C |
shows how this subroutine may be implemented for different types of |
I/O devices. If you choose to omit this subroutine, TINY will assume |
that a BREAK condition never happens; to include it, simply replace |
locations 010C-010E with a JMP to your subroutine, which returns with |
the break condition recorded in the Carry flag (1 = BREAK, 0 = no |
BREAK). The Break condition is used to interrupt program execution, |
or to prematurely terminate a LIST operation. Tiny responds to the |
Break condition any time in the LIST, or just before examining the |
next statement in program execution. If a LIST statement included |
within a program is aborted by the Break condition, the Break |
condition must be held over to the next statement fetch (or repeated) |
to stop program execution also. |
All input to Tiny is buffered in a 72 character line, |
terminated by a Carriage Return ("CR"). Excess characters are |
ignored, as signaled by ringing the console/terminal bell. When the |
CR is typed in, Tiny will echo it with a Linefeed, then proceed to |
process the information in the line. If a typing error occurs during |
the input of either a program line or data for an INPUT statement, |
the erroneous characters may be deleted by "backspacing" over them |
and retyping. If the entire line is in error, it may be canceled |
(and thus ignored) by typing the "Cancel" key. The Backspace code is |
located near the beginning of the program (location 010F), and is |
set by default to "left-arrow" or ASCII Underline (shift-O on your |
Teletype). To change this to the ASCII Standard Backspace code (or |
anything else you choose), the contents of location 010F may be |
changed to the desired code. Similarly the Cancel code is located at |
memory address 0110, and is set by default to the ASCII Cancel code |
(Control-X). Four characters which may not be used for line edits |
(Backspace or Cancel) are DC3 (hex 13), LF (0A), NUL (00), and DEL |
(FF). These codes are trapped by the TINY BASIC input routines |
before line edits are tested. |
When Tiny ends a line (either input or output), it types a CR, |
two pad characters, a Linefeed, and one more pad character. The pad |
character used is defined by the sign bit in location 0111, and is |
set by default to the "Rubout" or Delete code (hex FF; Location 0111 |
Bit 7 = 1) to minimize synchronization loss for bit-banger I/O |
routines. The pad character may be changed to a Null (hex 00) by |
setting the sign of location 0111 to 0. The remainder of this byte |
defines the number of Pad characters between the CR and linefeed. |
More than two pad characters may be required if large user programs |
are to be loaded from tape (see comments on Tape Mode, below). |
TINY BASIC has a provision for suppressing output (in |
particular line prompts) when using paper tape for loading a program |
or inputting data. This is activated by the occurrence of a Linefeed |
in the input stream (note that the user normally has no cause to type |
a Linefeed since it is echoed in response to each CR), and disables |
all output (including program output) until the tape mode is |
deactivated. This is especially useful in half-duplex I/O systems |
such as that supported by Mikbug, since any output would interfere |
with incoming tape data. The tape mode is turned off by the |
occurrence of an X-OFF character (ASCII DC3, or Control-S) in the |
input, by the termination of an executing program due to an error, or |
after the execution of any statement or command which leaves Tiny in |
the command mode. The tape mode may be disabled completely by |
replacing the contents of memory location 0112 with a 00. |
|
3 |
|
Memory location 0113 is of interest to those 6800 users with |
extensive operating systems. Normally Tiny reserves 32 bytes of |
stack space for use by the interpreter and I/O routines (including |
interrupts). Up to half of these may be used by Tiny in normal |
operation, leaving not more than 16 bytes on the stack for I/O. If |
your system allows nested interrupts or uses much more than ten or |
twelve stack bytes for any purpose, additional space must be |
allocated on the stack. Location 0113 contains the reserve stack |
space parameter used by Tiny, and is normally set to 32 (hex 20). If |
your system requires more reserve, this value should be augmented |
accordingly before attempting to run the interpreter. |
All of these memory locations are summarized in Appendix D. |
Note that there are no Input or Output instructions or interrupt |
disables in the interpreter itself; aside from the routines provided |
for your convenience (which you may connect or disconnect), your |
system has complete control over the I/O and interrupt structure of |
the TINY BASIC environment. |
|
TINY BASIC is designed to use all of the memory available to it |
for user programs. This is done by scanning all the memory from the |
beginning of the user program space (e.g. 0900 for the standard 6800 |
version) for the end of contiguous memory. This then becomes the |
user program space, and any previous contents may be obliterated. |
If it is desired to preserve some part of this memory for machine |
language subroutines or I/O routines, it will be necessary to omit |
the memory scan initialization. This is facilitated in TINY BASIC by |
the definition of two starting addresses. Location 0100 (or the |
beginning of the interpreter) is the "Cold Start" entry point, and |
makes no assumptions about the contents of memory, except that it is |
available. Location 0103 is the "Warm Start" entry point, and |
assumes that the upper and lower bounds of the user program memory |
have been defined, and that the program space is correctly |
formatted. The Warm Start does not destroy any TINY BASIC programs |
in the program space, so it may be used to recover from catastrophic |
failures. The lower bound is stored in locations 0020-0021 and the |
upper bound is in locations 0022-0023. When using the Warm Start to |
preserve memory, you should be sure these locations contain the |
bounds of the user space. Also when using the Warm Start instead of |
the Cold Start, the first command typed into TINY should be "CLEAR" |
to properly format the program space. |
|
|
STATEMENTS |
|
TINY BASIC is a subset of Dartmouth BASIC, with a few |
extensions to adapt it to the microcomputer environment. Appendix B |
contains a BNF definition of the language; the discussion here is |
intended to enable you to use it. When TINY issues a line prompt (a |
colon on the left margin) you may type in a statement with or without |
a line number. If the line number is included, the entire line is |
inserted into the user program space in line number sequence, without |
further analysis. Any previously existing line with the same line |
number is deleted or replaced by the new line. If the new line |
consists of a line number only, it is considered a deletion, and |
nothing is inserted. Blanks are not significant to TINY, so blanks |
|
|
4 |
|
imbedded in the line number are ignored; however, after the first |
non-blank, non-numeric character in the line, all blanks are |
preserved in memory. |
The following are valid lines with line numbers! |
|
123 PRINT "HELLO" |
456 G O T O 1 2 3 |
7 8 9 PRINT "THIS IS LINE # 789" |
123 |
32767 PRINT "THIS IS THE LARGEST LINE #" |
1PRINT"THIS, IS THE SMALLEST LINE #" |
10000 TINY BASIC DOES NOT CHECK |
10001 FOR EXECUTABLE STATEMENTS ON INSERTION. |
|
0 Is not a valid line number. |
|
If the input line does not begin with a line number it is |
executed directly, and must consist of one of the following statement |
types: |
|
LET GOTO REM |
IF...THEN GOSUB CLEAR |
INPUT RETURN LIST |
PRINT END RUN |
|
These statement types are discussed in more detail in the pages |
to follow. |
Note that all twelve statement types may be used in either the |
Direct Execution mode (without a line number) or in a program |
sequence (with a line number). Two of the statements (INPUT and RUN) |
behave slightly differently in these two operating modes, but |
otherwise each statement works the same in Direct Execution as within |
a program. Obviously there is not much point in including such |
statements as RUN or CLEAR in a program, but they are valid. |
Similarly, a GOSUB statement executed directly, though valid, is |
likely to result in an error stop when the corresponding RETURN |
statement is executed. |
|
|
EXPRESSIONS |
|
Many of these statement types involve the use of EXPRESSIONS. |
An Expression is the combination of one or more NUMBERS or VARIABLES, |
joined by OPERATORS, and possibly grouped by Parentheses. There are |
four Operators: |
+ addition |
- subtraction |
* multiplication |
/ division |
These are hierarchical, so that in an expression without parentheses, |
multiplication and division are performed before addition and |
subtraction. Similarly, sub-expressions within parentheses are |
evaluated first. Otherwise evaluation proceeds from left to right. |
Unary operators (+ and -) are allowed in front of an expression to |
denote its sign. |
|
|
5 |
|
A Number is any sequence of decimal digits (0, 1, 2, ... 9), |
denoting the decimal number so represented. Blanks have no |
significance and may be imbedded within the number for readability if |
desired, but commas are not allowed. All numbers are evaluated as |
16-bit signed numbers, so numbers with five or more digits are |
truncated modulo 65536, with values greater than 32767 being |
considered negative. The following are some valid numbers (note |
that the last two are equivalent to the first two in TINY): |
|
0 |
100 |
10 000 |
1 2 3 4 |
32767 |
65536 |
65 636 |
|
A Variable is any Capital letter (A, B, ... Z). This variable |
is assigned a fixed location in memory (two bytes, the address of |
which is twice the ASCII representation of the variable name). It |
may assume any value in the range, -32768 to +32767, as assigned to |
it by a LET or INPUT statement. |
The following are some examples of valid expressions: |
A |
123 |
1+2-3 |
B-14*C |
(A+B)/(C+D) |
-128/(-32768+(I*1)) |
(((((Q))))) |
|
All expressions are evaluated as integers modulo 65536. Thus |
an expression such as |
N / P * P |
may not evaluate to the same value as (N), and in fact this may be |
put to use to determine if a variable is an exact multiple of some |
number. TINY BASIC also makes no attempt to discover arithmetic |
overflow conditions, except in the case of an attempt to divide by |
zero (which results in an error stop). Thus all of the following |
expressions evaluate to the same value: |
-4096 |
15*4096 |
32768/8 |
30720+30720 |
|
TINY BASIC allows two intrinsic functions. These are: |
RND (range) |
USR (address,Xreg,Areg) |
Either of these functions may be used anywhere an (expression) is |
appropriate. |
|
|
|
|
|
|
|
6 |
|
FUNCTIONS |
|
|
RND (range) |
|
This function has as its value, a positive pseudo-random number |
between zero and range-1, inclusive. If the range argument is zero |
an error stop results. |
|
|
|
USR (address) |
USR (address,Xreg) |
USR (address,Xreg,Areg) |
|
This function is actually a machine-language subroutine call to |
the address in the first argument. If the second argument is |
included the index registers contain that value on entry to the |
subroutine, with the most significant part in X. If the third |
argument is included, the accumulators contain that value on entry to |
the subroutine, with the least significant part in A. On exit, the |
value in the Accumulators (for the 6800; A and Y for the 6502) |
becomes the value of the function, with the least significant part in |
A. All three arguments are evaluated as normal expressions. |
It should be noted that machine language subroutine addresses |
are 16-bit Binary numbers. TINY BASIC evaluates all expressions to |
16-bit binary numbers, so any valid expression may be used to define |
a subroutine address. However, most addresses are expressed in |
hexadecimal whereas TINY BASIC only accepts numerical constants in |
decimal. Thus to jump to a subroutine at hex address 40AF, you must |
code USR(16559). Hex address FFB5 is similarly 65461 in decimal, |
though the equivalent (-75) may be easier to use. |
For your convenience two subroutines have been included in the |
TINY BASIC interpreter to access memory. If S contains the address |
of the beginning of the TINY BASIC interpreter (256 for standard |
6800, 512 for standard 6502, etc.), then location S+20 (hex 0114) is |
the entry point of a subroutine to read one byte from the memory |
address in the index register, and location S+24 (hex 0118) is the |
entry point of a subroutine to store one byte into memory. |
Appendix E gives examples of the USR function. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
7 |
|
STATEMENT TYPES |
|
|
PRINT print-list |
PR print-list |
|
This statement prints on the console/terminal the values of the |
expressions and/or the contents of the strings in the print-list. |
The print-list has the general form, |
item,item... or item;item... |
The items may be expressions or alphanumeric strings enclosed in |
quotation marks (e.g. "STRING"). Expressions are evaluated and |
printed as signed numbers; strings are printed as they occur in the |
PRINT statement. When the items are separated by commas the printed |
values are justified in columns of 8 characters wide; when semicolons |
are used there is no separation between the printed items. Thus, |
PRINT 1,2,3 |
prints as |
1 2 3 |
and |
PRINT 1;2;3 |
prints as |
123 |
Commas and semicolons, strings and expressions may be mixed in one |
PRINT statement at will. |
If a PRINT statement ends with a comma or semicolon TINY BASIC |
will not terminate the output line so that several PRINT statements |
may print on the same output line, or an output message may be |
printed on the same line as an input request (see INPUT). When the |
PRINT statement does not end with a comma or semicolon the output is |
terminated with a carriage return and linefeed (with their associated |
pad characters). To aid in preparing data tapes for input to other |
programs, a colon at the end of a print-list will output an "X-OFF" |
control character just before the Carriage Return. |
|
Although the PRINT statement generates the output immediately |
while scanning the statement line, output lines are limited to 125 |
characters, with excess suppressed. |
|
While the Break key will not interrupt a PRINT statement in |
progress, the Break condition will take effect at the end of the |
current PRINT statement. |
|
The following are some examples of valid PRINT statements: |
PRINT "A=";A,"B+C=";B+C |
PR (one blank line) |
PRI (prints the value of I) |
PRINT 1,","Q*P;",",R/42: |
|
|
|
|
|
|
|
|
|
8 |
|
INPUT input-list |
|
This statement checks to see if the current input line is |
exhausted. If it is, a question mark is prompted with an X-ON |
control character, and a new line is read in. Then or otherwise, the |
input line is scanned for an expression which is evaluated. The |
value thus derived is stored in the first variable in the input-list. |
If there are more variables in the input-list the process is |
repeated. In an executing program, several values may be input on a |
single request by separating them with commas. If these values are |
not used up in the current INPUT statement they are saved for |
subsequent INPUT statements. The question mark is prompted only when |
a new line of input values is required. Note that each line of input |
values must be terminated by a carriage return. Since expressions |
may be used as input values, any letter in the input line will be |
interpreted as the value of that variable. Thus if a program sets |
the value of A to 1, B to 2, and C to 3, and the following statement |
occurs during execution: |
INPUT X,Y,Z |
and the user types in |
A,C,B |
the values entered into X, Y, and Z will be 1, 3, and 2, |
respectively, just as if the numbers had been typed in. Note also |
that blanks on the input line are ignored by TINY, and the commas are |
required only for separation in cases of ambiguity. In the example |
above |
ACB |
could have been typed in with the same results. However an input, |
line typed in as |
+1 -3 +6 0 |
will be interpreted by TINY as a single value (=58) without commas |
for separators. There is one anomaly in the expression input |
capability: if in response to this INPUT, the user types, |
RND+3 |
TINY will stop on a bad function syntax error (the RND function must |
be of the form, RND(x)); but if the user types, |
RN,D+3 |
the values in the variables R, N, and the expression (D+3) will be |
input. This is because in the expression evaluator the intrinsic |
function names are recognized before variables, as long as they are |
correctly spelled. |
|
Due to the way TINY BASIC buffers its input lines, the INPUT |
statement cannot be directly executed for more than one variable at a |
time, and if the following statement is typed in without a line |
number, |
INPUT A,B,C |
the value of B will be copied to A, and only one value (for C) will |
be requested from the console/terminal. Similarly, the statement, |
INPUT X,1,Y,2,Z,3 |
will execute directly (loading X, Y, and Z with the values 1, 2, and |
3), requesting no input, but with a line number in a program this |
statement will produce an error stop after requesting one value. |
|
If the number of expressions in the input line does not match |
the number of variables in the INPUT statement, the excess input is |
|
9 |
|
saved for the next INPUT statement, or another prompt is issued for |
more data. The user should note that misalignment in these |
circumstances may result in incorrect program execution (the wrong |
data to the wrong variables). If this is suspected, data entry may be |
typed in one value at a time to observe its synchronization with |
PRINT statements in the program. |
There is no defined escape from an input request, but if an |
invalid expression is typed (such as a period or a pair of commas) an |
invalid expression error stop will occur. |
|
Because Tiny Basic does not allow arrays, about the only way to |
process large volumes of data is through paper tape files. Each |
input request prompt consists of a question mark followed by an X-ON |
(ASCII DC1) control character to turn on an automatic paper tape |
reader on the Teletype (if it is ready). A paper tape may be |
prepared in advance with data separated by commas, and an X-OFF |
(ASCII DC3 or Control-S) control character preceding the CR (a |
Teletype will generally read at least one more character after the |
X-OFF). In this way the tape will feed one line at a time, as |
requested by the succession of INPUT statements. This tape may also |
be prepared from a previous program output (see the PRINT |
statement). |
|
|
|
|
|
LET var = expression |
var = expression |
|
This statement assigns the value of the expression to the |
variable (var). The long form of this statement (i.e. with the |
keyword LET) executes slightly faster than the short form. The |
following are valid LET statements: |
|
LET A = B+C |
I = 0 |
LET Q = RND (RND(33)+5) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
10 |
|
GOTO expression |
|
The GOTO statement permits changes in the sequence of program |
execution. Normally programs are executed in the numerical sequence |
of the program line numbers, but the next statement to be executed |
after a GOTO has the line number derived by the evaluation of the |
expression in the GOTO statement. Note that this permits you to |
compute the line number of the next statement on the basis of program |
parameters during program execution. An error stop occurs if the |
evaluation of the expression results in a number for which there is |
no line. If a GOTO statement is executed directly, it has the same |
effect as if it were the first line of a program, and the RUN |
statement were typed in, that is, program execution begins from that |
line number, even though it may not be the first in the program. |
Thus a program may be continued where it left off after correcting |
the cause of an error stop. The following are valid GOTO |
statements: |
GOTO 100 |
GO TO 200+I*10 |
G 0 T 0 X |
|
|
|
|
|
|
GOSUB expression |
|
The GOSUB statement is like the GOTO statement, except that TINY |
remembers the line number of the GOSUB statement, so that the next |
occurrence of a RETURN statement will result in execution proceeding |
from the statement following the GOSUB. Subroutines called by GOSUB |
statements may be nested to any depth, limited only by the amount of |
user program memory remaining. Note that a GOSUB directly executed |
may result in an error stop at the corresponding RETURN. The |
following are some examples of valid GOSUB statements: |
GOSUB 100 |
GO SUB 200+I*10 |
|
|
|
|
|
|
RETURN |
|
The RETURN statement transfers execution control to the line |
following the most recent unRETURNed GOSUB. If there is no matching |
GOSUB an error stop occurs. |
|
|
|
|
|
|
|
|
11 |
|
IF expression rel expression THEN statement |
IF expression rel expression statement |
|
The IF statement compares two expressions according to one of |
six relational operators. If the relationship is True, the statement |
is executed; if False, the associated statement is skipped. The six |
relational operators are: |
= equality |
< less than |
> greater than |
<= less or equal (not greater) |
>= greater or equal (not less) |
<>, >< not equal (greater or less) |
|
The statement may be any valid TINY BASIC statement (including |
another IF statement). The following are valid IF statements: |
IF I>25 THEN PRINT "ERROR" |
IF N/P*P=N GOTO 100 |
IF 1=2 Then this is nonsense |
IF RND (100) > 50 THEN IF I <> J INPUT Q,R |
|
|
|
|
|
|
END |
|
The END statement must be the last executable statement in a |
program. Failure to include an END statement will result in an error |
stop after the last line of the program is executed. The END |
statement may be used to terminate a program at any time, and there |
may be as many END statements in a program as needed. The END |
statement also clears out any saved GOSUB line numbers remaining, and |
may be used for that purpose in the direct execution mode. |
|
|
|
|
|
|
REM comments |
|
The REM statement permits comments to be interspersed in the |
program. Its execution has no effect on program operation, except |
for the time taken. |
|
|
|
|
|
|
|
|
|
|
|
12 |
|
CLEAR |
|
The CLEAR statement formats the user program space, deleting |
any previous programs. If included in a program (i.e. with a line |
number) the program becomes suicidal when the statement is executed, |
although no error results. If the Warm Start is used to initialize |
the interpreter, this must be the first command given. |
|
|
|
RUN |
RUN,expression-list |
|
The RUN statement is used to begin program execution at the |
first (lowest) line number. If the RUN statement is directly |
executed, it may be followed by a comma, followed by values to be |
input when the program executes an INPUT statement. |
If the RUN statement is included in a program with a line |
number, its execution works like a GO TO first statement of the |
program. |
|
|
|
LIST |
LIST expression |
LIST expression,expression |
|
The LIST statement causes part or all of the user program to be |
listed. If no parameters are given, the whole program is listed. A |
single expression parameter in evaluated to a line number which, if |
it exists, is listed. If both expression parameters are given, all |
of the lines with line numbers between the two values (inclusive) are |
listed. If the last expression in the LIST statement evaluates to a |
number for which there is no line, the next line above that number |
which does exist (if any) is listed as the last line. Zero is not a |
valid line number, and an error stop will occur if one of the |
expressions evaluates to zero. A LIST statement may be included as |
part of the program, which may be used for printing large text |
strings such as instructions to the operator. A listing may be |
terminated by the Break key. |
If the terminal punch (or cassette recorder) is turned on for a |
LIST operation, the tape may be saved to reload the program into TINY |
at a later time. |
The following are valid LIST statements: |
LIST |
LIST 75+25 (lists line 100) |
LIST 100,200 |
LIST 500,400 (lists nothing) |
|
|
|
|
|
|
|
|
|
13 |
|
A P P E N D I X A |
|
ERROR MESSAGE SUMMARY |
|
|
0 Break during execution |
8 Memory overflow; line not inserted |
9 Line number 0 not allowed |
13 RUN with no program in memory |
18 LET is missing a variable name |
20 LET is missing an = |
23 Improper syntax in LET |
25 LET is not followed by END |
34 Improper syntax in GOTO |
37 No line to GO TO |
39 Misspelled GOTO |
40,41 Misspelled GOSUB |
46 GOSUB subroutine does not exist |
59 PRINT not followed by END |
62 Missing close quote in PRINT string |
73 Colon in PRINT is not at end of statement |
75 PRINT not followed by END |
95 IF not followed by END |
104 INPUT syntax bad - expects variable name |
123 INPUT syntax bad - expects comma |
124 INPUT not followed by END |
132 RETURN syntax bad |
133 RETURN has no matching GOSUB |
134 GOSUB not followed by END |
139 END syntax bad |
154 Can't LIST line number 0 |
164 LIST syntax error - expects comma |
183 REM not followed by END |
184 Missing statement type keyword |
186 Misspelled statement type keyword |
188 Memory overflow: too many GOSUB's ... |
211 ... or expression too complex |
224 Divide by 0 |
226 Memory overflow |
232 Expression too complex ... |
233 ... using RND ... |
234 ... in direct evaluation; |
253 ... simplify the expression |
259 RND (0) not allowed |
266 Expression too complex ... |
267 ... for RND |
275 USR expects "(" before arguments |
284 USR expects ")" after arguments |
287 Expression too complex ... |
288 ... for USR |
290 Expression too complex |
293 Syntax error in expression - expects value |
296 Syntax error - expects ")" |
298 Memory overflow (in USR) |
303 Expression too complex (in USR) |
|
|
14 |
|
304 Memory overflow (in function evaluation) |
306 Syntax error - expects "(" for function arguments |
330 IF syntax error - expects relation operator |
|
Other error message numbers may possibly occur if the |
interpreter is malfunctioning. If this happens, check the program in |
memory, or reload it, and try again. |
|
Error number 184 may also occur if TINY BASIC is incorrectly |
interfaced to the keyboard input routines. A memory dump of the |
input line buffer may disclose this kind of irregularity. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
15 |
|
A P P E N D I X B |
|
FORMAL DEFINITION OF TINY BASIC |
|
|
line ::= number statement CR |
statement CR |
statement ::= PRINT printlist |
PR printlist |
INPUT varlist |
LET var = expression |
var = expression |
GOTO expression |
GOSUB expression |
RETURN |
IF expression relop expression THEN statement |
IF expression relop expression statement |
REM commentstring |
CLEAR |
RUN |
RUN exprlist |
LIST |
LIST exprlist |
printlist ::= |
printitem |
printitem : |
printitem separator printlist |
printitem ::= expression |
"characterstring" |
varlist ::= var |
var , varlist |
exprlist ::= expression |
expression , exprlist |
expression ::= unsignedexpr |
+ unsignedexpr |
- unsignedexpr |
unsignedexpr ::= term |
term + unsignedexpr |
term - unsignedexpr |
term ::= factor |
factor * term |
factor / term |
factor ::= var |
number |
( expression ) |
function |
function ::= RND ( expression ) |
USR ( exprlist ) |
number ::= digit |
digit number |
separator ::= , ! ; |
var ::= A ! B ! ... ! Y ! Z |
digit ::= 0 ! 1 2 ! ... ! 9 |
relop ::= < ! > ! = ! <= ! >= ! <> ! >< |
|
|
|
16 |
|
|
A P P E N D I X C |
|
IMPLEMENTING I/O ROUTINES |
|
COSMAC |
|
COSMAC TINY occupies the same space as 6800 TINY -- 0100-08FF. |
Similarly, the general parameters occupy 0020-00B7, as defined in |
the manual. However, COSMAC TINY also uses locations 0011-001F to |
contain copies of interpreter parameters and other run-time data; do |
not attempt to use these locations while running TINY. |
|
Like all Itty Bitty Computer software, COSMAC TINY contains no I/O |
instructions (nor references to Q or EF1-4), no interrupt enables or |
disables, and no references to an operating system. The three jumps |
(LBR instructions) at 0106, 0109, and 010C provide all necessary |
I/O, as defined in the manual. If you are using UT3 or UT4, you may |
insert the following LBR instructions, which jump to the necessary |
interface routines: |
|
.. LINKS TO UT3/4 |
0106 C0076F LBR UTIN |
0109 C00776 LBR UTOUT |
010C C00766 LBR UTBRK |
|
If you are not using the RCA monitor, you must write your own I/O |
routines. For this the standard subroutine call and return linkages |
are used, except that D is preserved through calls and returns by |
storing it in RF.1. Registers R2-RB and RD contain essential |
interpreter data, and if the I/O routines make any use of any of |
them they should be saved and restored. Note however, that R2-R6 |
are defined in the customary way and may be used to nest subroutine |
calls if needed. R0, R1, RC, RE and RF are available for use by the |
I/O routines, as is memory under R2. Both the call and return |
linkages modify X and the I/O data character is passed in the |
accumulator ("D", not RD). |
|
After connecting TINY to the I/O routines, start the processor at |
0100 (the Cold Start). Do not attempt to use the Warm Start without |
entering the Cold Start at least once to set up memory from |
0011-0023. Any register may be serving as program counter when |
entering either the Cold Start or the Warm Start. |
|
The USR function works the same way as described in the manual, |
except that the second argument in the call is loaded into R8, and |
the third argument is loaded into RA with the least significant |
byte also in the Accumulator. On return RA.1 and the accumulator |
contain the function value (RA.0 is ignored). The machine language |
subroutine must exit by a SEP R5 instruction. USR machine language |
subroutines may use R0, R1, R8, RA, RC-RF, so long as these do not |
conflict with I/O routine assignments. TINY BASIC makes no internal |
use of R0, R1, RC, or RE. |
|
RCA Corporation funded the development of COSMAC TINY BASIC, and it |
is by RCA's permission that it is made available. |
|
17 |
If you do not have access to a monitor in ROM with ASCII I/O |
built in, you will have to write your own I/O routines. Most likely |
you have something connected to a parallel port for the keyboard |
input; output may be some parallel port also, or you may want to |
use the 1861 video display for a gross dot-matrix kind of text |
display. For the moment, let's assume you have parallel ports, |
Port C (N=1100) for input, and port 4 (N=0100) for output. Assume |
also that EF4 controls both input and output. This is the situation |
you would have if you took an ordinary ELF and used the hex input |
and display with the single "input" button to step through the |
characters. You need for this configuration, two routines, which |
might look something like this: |
0106 C0 00E0 LBR KEYIN |
0109 C0 00E7 LBR DISPL |
... |
00E0 3FE0 KEYIN BN4 * |
00E2 E2 SEX 2 |
00E3 6C INP 4 |
00E4 37E4 B4 * |
00E6 68 LSKP |
00E7 3FE7 DISPL BN4 * |
00E9 E2 SEX 2 |
00EA 73 STXD |
00EB 52 STR 2 |
00EC 64 OUT 4 |
00ED 37ED B4 * |
00EF D5 SEP 5 |
Of course if you have a keyboard on Port F you will change |
the INP instruction to match; if the keyboard pulls EF3 down, then |
you must change the first pair of BN4/B4 instructions to BN3/B3 |
instructions and change the LSKP to a NOP (C4 or E2). If your |
input comes from some device that already displayed the character |
typed, then change the LSKP to a Return (D5). |
Similarly, if the output is to a different port you must |
change the OUT instruction to fit it, and the second pair of BN4/B4 |
instructions to match the control line being used. Notice that |
the LSKP instruction is only there to prevent your waiting on the |
EF4 line twice for each keyin, and should be removed (changed to |
a NOP) as soon as you connect up real input and output ports. |
Many 1802 systems come equipped with a video output using |
the 1861 chip. If you have this, you should get a copy of the |
February and April 1979 issues of KILOBAUD MICROCOMPUTING (formerly |
just KILOBAUD). I have a two-part article published in these two |
issues which explains how to put text on the 1861 graphics display, |
with particular emphasis on how to connect it to TINY BASIC. |
So far I have not mentioned the Break test. If you leave |
that part unchanged, Tiny will work just fine, but you cannot stop |
a listing or a program that is getting too long. After you get |
your keyboard and display connected up and working, you may want |
to use EF4 (or some other flag) as a Break input. It is possible |
to use the same flag for Break as for "input ready", if you want |
Tiny to stop executing when you press a key on your keyboard (this |
does not affect the INPUT instruction, which is obviously waiting |
for that keyin). This code will do that: |
010C C000F0 LBR BRKT |
... |
00F0 FC00 BRKT ADI 0 |
00F2 3FF6 BN4 EXIT |
00F4 FF00 SMI 0 |
00F6 D5 EXIT SEP R5 |
Notice that the only function of this routine is to set the |
Carry (DF) when EF4 is true (low) and clear it otherwise. |
|
18 |
|
KIM |
|
The Teletype I/O routines in the MOS Technology KIM system may |
be used for the character input and output requirements of TINY BASIC |
6502. The following break routine is included in Tiny to test the |
serial data line at 1740; Since TINY BASIC 6502 does not use the |
lower part of memory page 01, the break test routine is ORG'ed to |
execute in that space: |
|
; BREAK TEST FOR KIM |
0100 AD4017 KIMBT LDA KTTY LOOK AT TTY |
0103 18 CLC C=O IF IDLE |
0104 300E BMI KIMX IDLE |
0106 AD4017 LDA KTTY WAIT FOR END |
0109 10FB BPL *-3 |
010B 200E01 KLDY JSR *+3 |
010E A9FF LDA #255 DELAY 2 RUBOUT TIMES |
0110 20A01E JSR OUTCH |
0113 38 SEC C=1 IF BREAK |
0114 60 KIMX RTS |
|
To run TINY BASIC 6502 load the paper tape into your Teletype |
reader, type "L", and turn on the reader. Then key in the following |
Jumps: |
|
; JUMPS TO KIM |
0206 4C5A1E JMP GETCH CHARACTER INPUT |
0209 4CA01E JMP OUTCH CHARACTER OUTPUT |
020C 4C0001 JMP KIMBT BREAK TEST |
|
It is recommended that you save a copy of memory on tape |
(0100-0114 and 0200-0AFF) before going any further. Or you may |
prefer to save it on audio cassette. Set up the starting address for |
Tiny at 0200, and type "G". |
Because of the awkwardness of putting memory in the 4K gap left |
in the KIM-1 system, an alternate version is available which executes |
out of 2000-28FF. For this version the Cold Start is at 2000 and |
other addresses are at 200x instead of 020x (cf. 010x in Appendix D). |
|
|
JOLT or TIM |
|
JOLT systems may not always have memory loaded in the space |
from 0200 on up, so a special version has been prepared in which the |
interpreter resides in the space 1000-18FF. This is the only |
difference between the JOLT version and the KIM version, so if your |
JOLT or TIM system has contiguous memory from Page 00 you may prefer |
to use the KIM version to gain the extra memory space. Since the |
serial data in the JOLT/TIM systems is not the same as KIM, a special |
break test routine has also been provided for those systems: |
|
; JOLT BREAK TEST |
0115 A901 JOLBT LDA #1 LOOK AT TTY |
0117 2C026E BIT JTTY |
011A 18 CLC C=0 IF IDLE |
|
|
19 |
|
011B F00E BEQ JOLTX IDLE |
011D 2C026E BIT JTTY WAIT FOR END |
0120 D0FB BNE *-3 |
0122 202501 JSR *+3 DELAY TWO CH TIMES |
0125 A9FF LDA #255 |
0127 20C672 JSR WRT |
012A 38 SEC C=1 = BREAK |
012B 60 JOLTX RTS |
|
To run, load the paper tape into your Teletype reader and type |
"LH". Then key in the following Jumps: |
|
; JUMPS TO JOLT/TIM |
1006 4CE972 JMP RDT CHARACTER INPUT |
1009 4CC672 JMP WRT CHARACTER OUTPUT |
100C 4C1501 JMP JOLBT BREAK TEST |
|
As with other versions, the Cold start is the beginning of the |
program (1000). |
|
|
|
MIKBUG |
|
Systems that use MIKBUG (TM Motorola) for console I/O may use |
the I/O routines in MIKBUG. The following break routine is provided |
in Tiny to test the PIA at 8004: |
|
* BREAK TEST FOR MIKBUG |
|
B68004 BREAK LDA A PIAA LOOK AT PIA |
0C CLC C=0 IF NONE |
2B0D BMI EXIT |
B68004 LDA A PIAA |
2AFB BPL *-3 WAIT FOR END |
8D00 BSR *+2 |
86FF LDA A #$FF DELAY ONE |
BD0109 JSR TYPE CHARACTER TIME |
0D SEC C=1 IF BREAK |
39 EXIT RTS |
|
To run, load the paper tape into your Teletype reader and type |
"L". Then key in the following Jumps: |
|
* JUMPS TO MIKBUG |
ORG $0106 |
0106 7EE1AC JMP $E1AC CHARACTER INPUT |
0109 7EE1D1 JMP $E1D1 CHARACTER OUTPUT |
010C 7E08FD JMP $08FD BREAK TEST |
|
It is recommended that you save a copy of memory on tape |
(0100-08FF) before going any further. Set the starting address in |
A048-A049 to 0100 and type "G". For your convenience the Cold Start |
entry leaves the Warm start entry set up in the Mikbug stack, so that |
after a reset a simple "G" command will result in a Warm start and |
preserve the user programs. |
|
20 |
|
OTHER |
|
For standard systems (and for special systems with I/O other |
than that provided), subroutines must be supplied by the user to |
interface TINY to the operator. For ACIA input or output the |
following routines may be used, or they may serve as examples for |
your coding (6800 opcodes are shown). They should be assembled for |
your ACIA address, and in some memory location which is not |
contiguous with the TINY BASIC user program memory (which may be |
destroyed by the Cold Start). If nothing else is available, |
locations 00D8-00FF are not used by Tiny and may be used for this |
purpose. |
|
* |
* ACIA I/O |
* |
B6XXXX BREAK LDA A ACIA |
47 ASR A CHECK FOR TYPEIN |
2406 BCC BRX NO, NOT BREAK |
B6XXXY LDA A ACIA+1 GET IT |
2601 BNE BRX NOT NULL IS BREAK |
0C CLC IGNORE NULLS |
39 BRX RTS |
B6XXXX INPUT LDA A ACIA |
47 ASR A |
24FA BCC INPUT WAIT FOR A CHARACTER |
B6XXXY LDA A ACIA+1 GET IT |
36 OUTPUT PSH A SAVE CHARACTER |
B6XXXX LDA A ACIA |
8402 AND A #2 WAIT FOR READY |
27F9 BEQ OUTPUT+1 |
32 PUL A |
B7XXXY STA A ACIA+1 OUTPUT CHARACTER |
39 RTS |
|
Note that this routine will accept any non-null character |
typein as a break. Alternatively we could look at the Framing Error |
status, but if a character has been input this status will not show |
up until that character is read in, rendering it ineffective in some |
cases. Nulls are excepted as break characters since one or more of |
them may follow the carriage return in an input tape, and still be |
pending. Note that for this to work properly, the pad character |
defined in location 0111 should be set to NULL (hex 00). |
|
The 6800 "R" version of TINY BASIC includes these routines in |
the code, as shown here. Locations 08FA-08FC contain a JMP to the |
break test at the beginning of this block. You should alter the ACIA |
addresses to suit your system before using the subroutines. |
|
|
|
|
|
|
|
|
|
21 |
|
CRT OR TVT |
|
If a TV Typewriter is used for I/O it may be desirable to |
remove excess control characters from the output stream. All |
controls except Carriage Return may be removed by the following |
instructions at the beginning of the output subroutine (6800 opcodes |
shown): |
|
39 RTS |
810A OUTPUT CMP A #0A |
2FFB BLE OUTPUT-1 |
|
Only nulls, Rubouts, X-ON and X-OFF may be deleted by changing the |
CMP to a TST A. Nulls may be passed through by also changing the BLE |
to a BMI. |
|
Some TV Typewriters do not scroll up when the cursor reaches |
the bottom of the screen, but rather wrap the cursor around to the |
top of the screen, writing over the previously displayed data. With |
this kind of display it is essential that the I/O routines (or the |
hardware) clear to the end of the line whenever a CR-LF is output, |
so that previous data does not interfere with the new. If your I/O |
routines are fixed in ROM, some sort of preprocessor may be required |
to recognize output CR's and convert them to the appropriate sequence |
of control functions. It may also be necessary to trap input CR's |
(suppressing their echo) since Tiny generally responds with both |
another CR and a linefeed. |
|
Some users prefer to concatenate all output into one "line" of |
print, using the terminal comma or semicolon to suppress the line |
breaks. Since TINY was designed to limit line lengths to less than |
128 characters, if this sort of concatenation is attempted it will |
appear that TINY has quit running. To eliminate the print |
suppression the most significant two bits of the print control byte |
(location 00BF in most versions) may be cleared to zero periodically |
with the USR function or in the output driver routine. The least |
significant three bits of this same byte are used for the "comma |
spacing" in the PRINT statement, and should be left unaltered. |
|
|
|
CASSETTE I/O |
|
Officially, TINY only speaks to one peripheral--the console. |
However a certain amount of file storage may be simulated by |
attaching these peripherals (such as cassette systems) to the |
character input and output routines. If the same electrical and |
software interface is used this is very easy. Otherwise the I/O |
drivers will require special routines to recognize control characters |
in the input and output data for setting internal switches which |
select one of several peripherals. The USR function may also be |
used either to directly call I/O routines or to alter switches in |
memory. |
|
|
|
|
22 |
|
|
|
|
|
A P P E N D I X D |
|
LOW MEMORY MAP |
|
|
LOCATION SIGNIFICANCE |
-------- ------------ |
|
0000-000F Not used by any version of TINY |
0011-001F COSMAC version temporaries |
0020-0021 Lowest address of user program space |
0022-0023 Highest address of program space |
0024-0025 Program end + stack reserve |
0026-0027 Top of GOSUB stack |
0028-002F Interpreter parameters |
0030-007F Input line buffer & Computation stack |
0080-0081 Random Number Generator workspace |
0082-0083 Variable "A" |
0084-0085 Variable "B" |
... ... |
00B4-00B5 Variable "Z" |
00B6-00C7 Interpreter temporaries |
00B8 Start of User program (PROTO) |
00C8-00D7 Sphere parameters (not 0020-002F) |
00D8-00FF Unused by standard version |
|
0100 Cold Start entry point (6800) |
0103 Warm Start entry point |
0106-0108 JMP (or JSR) to character input |
0109-010B JMP to character output |
010C-010E JMP to Break test |
010F Backspace code |
0110 Line Cancel code |
0111 Pad character |
0112 Tape Mode Enable flag (hex 80 = enabled) |
0113 Spare stack size |
0114 Subroutine to read one Byte |
from RAM to A (address in X) |
0118 Subroutine to store A into RAM |
at address in X |
|
0900 Beginning of User program (6800) |
|
Note that some of these addresses apply to the standard 6800 version. |
For other versions addresses above 0100 should be read as addresses |
above their respective starting address. |
|
|
|
|
|
|
|
23 |
|
A P P E N D I X E |
|
AN EXAMPLE PROGRAM |
|
|
10 REM DISPLAY 64 RANDOM NUMBERS < 100 ON 8 LINES |
20 LET I=0 |
30 PRINT RND (100), |
40 LET I=I+1 |
50 IF I/8*8=I THEN PRINT |
60 IF I<64 THEN GOTO 30 |
70 END |
|
|
100 REM PRINT HEX MEMORY DUMP |
109 REM INITIALIZE |
110 A=-10 |
120 B=-11 |
130 C=-12 |
140 D=-13 |
150 E=-14 |
160 F=-15 |
170 X = -1 |
175 O = 0 |
180 LET S = 256 |
190 REMARK: S IS BEGINNING OF TINY (IN DECIMAL) |
200 REM GET (HEX) ADDRESSES |
210 PRINT "DUMP: L,U"; |
215 REM INPUT STARTING ADDRESS IN HEX |
220 GOSUB 500 |
230 L=N |
235 REM INPUT ENDING ADDRESS IN HEX |
240 GOSUB 500 |
250 U=N |
275 REM TYPE OUT ADDRESS |
280 GOSUB 450 |
290 REM GET MEMORY BYTE |
300 LET N = USR (S+20,L) |
305 REM CONVERT IT TO HEX |
310 LET M = N/16 |
320 LET N = N-M*16 |
330 PRINT " "; |
335 REM PRINT IT |
340 GOSUB 400+M+M |
350 GOSUB 400+N+N |
355 REM END? |
360 IF L=U GO TO 390 |
365 L=L+1 |
370 IF L/16*16 = L GOTO 280 |
375 REM DO 16 BYTES PER LINE |
380 GO TO 300 |
390 PRINT |
395 END |
399 PRINT ONE HEX DIGIT |
400 PRINT O; |
|
|
24 |
|
401 RETURN |
402 PRINT 1; |
403 RETURN |
404 PRINT 2; |
405 RETURN |
406 PRINT 3; |
407 RETURN |
408 PRINT 4; |
409 RETURN |
410 PRINT 5; |
411 RETURN |
412 PRINT 6; |
413 RETURN |
414 PRINT 7; |
415 RETURN |
416 PRINT 8; |
417 RETURN |
418 PRINT 9; |
419 RETURN |
420 PRINT "A"; |
421 RETURN |
422 PRINT "B"; |
423 RETURN |
424 PRINT "C"; |
425 RETURN |
426 PRINT "D"; |
427 RETURN |
428 PRINT "E"; |
429 RETURN |
430 PRINT "F"; |
431 RETURN |
440 REM PRINT HEX ADDRESS |
450 PRINT |
455 REM CONVERT IT TO HEX |
460 N = L/4096 |
470 IF L<0 N=(L-32768)/4096+8 |
480 GOSUB 400+N+N |
483 LET N=(L-N*4096) |
486 GOSUB 400+N/256*2 |
490 GOSUB 400+(N-N/256*256)/16*2 |
495 GOTO 400+(N-N/16*16)*2 |
496 GOTO=GOSUB,RETURN |
500 REM INPUT HEX NUMBER |
501 REM FORMAT IS NNNNX |
502 REM WHERE "N" IS ANY HEX DIGIT |
505 N=0 |
509 REM INPUT LETTER OR STRING OF DIGITS |
510 INPUT R |
520 IF R=X RETURN |
525 REM CHECK FOR ERROR |
530 IF R>9999 THEN PRINT "BAD HEX ADDRESS |
531 REM NOTE ERROR STOP ON LINE 530 (ON PURPOSE!) |
535 REM CONVERT INPUT DECIMAL DIGITS TO HEX |
540 IF R>999 THEN N=N*16 |
545 IF R>99 THEN N=N*16 |
550 IF R>9 THEN N=N*16 |
|
25 |
|
555 IF R>0 THEN R=R+R/1000*1536+R/100*96+R/10*6 |
559 REM PICK UP NON-DECIMAL DIGIT LETTERS |
560 IF R<0 THEN LET R=-R |
565 REM ADD NEW DIGIT TO PREVIOUS NUMBER |
570 LET N=N*16+R |
580 GOTO 510 |
590 NOTE: DON'T NEED END HERE |
|
|
1000 TO RUN RANDOM NUMBER PROGRAM, TYPE "RUN" |
1010 IT WILL TYPE 8 LINES THEN STOP. |
1020 TO RUN HEX DUMP PROGRAM TYPE "GOTO 100" |
1030 IT WILL ASK FOR INPUT, TYPE 2 HEX ADDRESSES |
1040 EACH TERMINATED BY THE LETTER X, |
1050 AND SEPARATED BY A COMMA |
1055 (TYPE ALL ZEROS AS LETTER OH). |
1060 THE PROGRAM WILL DUMP MEMORY BETWEEN |
1070 THOSE TWO ADDRESSES, INCLUSIVE. |
1080 EXAMPLE: |
1090 :GOTO 100 |
1100 DUMP: L,U? AO3EX,AO46X |
1110 A03E EE FF |
1120 A040 00 11 22 33 44 55 66 |
1130 IF THE RANDOM NUMBER PROGRAM |
1140 IS REMOVED, OR IF YOU TYPE IN |
1150 :1 GOTO 100 |
1160 THEN YOU CAN GET THE SAME DUMP BY TYPING |
1170 :RUN,AO3EX,AO46X |
1180 . |
1190 NOTE THAT THIS PROGRAM DEMONSTRATES NEARLY |
1200 EVERY FEATURE AVAILABLE IN TINY BASIC. |
|
|
|
REMARK: TO FIND OUT HOW MUCH PROGRAM SPACE |
REM... YOU HAVE LEFT, TYPE: |
LET I=0 |
1 LET I=I+2 |
2 GOSUB 1 |
RUN |
REMARK: AFTER A FEW SECONDS, THIS WILL STOP |
REM... WITH AN ERROR; THEN TYPE: |
END |
PRINT "THERE ARE ";I;" BYTES LEFT" |
|
|
REM: TO EXIT FROM TINY BASIC TO YOUR MONITOR/DEBUGGER, |
LET S=256 |
REM (S AS IN LINE 180 ABOVE) |
LET B=0 |
IF P=6800 THEN LET B=63 |
REM: B IS SWI OR BRK INSTRUCTION |
LET A = USR (S+24,0,B) + USR (0) |
REM: THE FIRST CALL STORES A BREAK IN 0000 |
REM... THE SECOND CALL JUMPS TO IT. |
|
|
26 |