Subversion Repositories Kolibri OS

is a long line of low cost software for hobby computers.  We are

volume.  Please help us to stay in business by respecting the

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.

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.

                                  1

      TINY BASIC was conceived by the dragons at the People's

PCC newspaper and an offshoot newsletter.  The implementation of this

program follows the philosophy defined there.  The reader is referred

software.

cost) so that the whole system occupies only 2K of program memory

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

      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,

next statement in program execution.  If a LIST statement included

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

your system requires more reserve, this value should be augmented

      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

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

consists of a line number only, it is considered a deletion, and

                                  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

      32767 PRINT "THIS IS THE LARGEST 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

      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)

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

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

multiplication and division are performed before addition and

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

      0

      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

it by a LET or INPUT statement.

      The following are some examples of valid expressions:

      A

      123

      1+2-3

      B-14*C

      -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

      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

      USR (address)

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

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

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.

      item,item...    or      item;item...

quotation marks (e.g. "STRING").  Expressions are evaluated and

values are justified in columns of 8 characters wide; when semicolons

are used there is no separation between the printed items. Thus,

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

      PRI                       (prints the value of I)

      PRINT 1,","Q*P;",",R/42:

                                  8

single request by separating them with commas.  If these values are

subsequent INPUT statements.  The question mark is prompted only when

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

      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

      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

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

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

evaluation of the expression results in a number for which there is

effect as if it were the first line of a program, and the RUN

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

      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

      >               greater than

      >=              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

      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.

      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

      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

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

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

18    LET is missing a variable name

23    Improper syntax in LET

34    Improper syntax in GOTO

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.

interfaced to the keyboard input routines.  A memory dump of the

              INPUT varlist

              var = expression

              GOSUB expression

              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

the manual.  However, COSMAC TINY also uses locations 0011-001F to

instructions (nor references to Q or EF1-4), no interrupt enables or

(LBR instructions) at 0106, 0109, and 010C provide all necessary

insert the following LBR instructions, which jump to the necessary

interface routines:

                        ..  LINKS TO UT3/4

        0106 C0076F             LBR UTIN

        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

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

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

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.

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,

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

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

0103 18           CLC           C=O IF 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

      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

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

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 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

            ; JOLT BREAK TEST

0117 2C026E       BIT JTTY

011A 18           CLC           C=0 IF IDLE

                                  19

011B F00E         BEQ JOLTX     IDLE

011D 2C026E       BIT JTTY      WAIT FOR END

0122 202501       JSR *+3       DELAY TWO CH TIMES

0125 A9FF         LDA #255

0127 20C672       JSR WRT

012A 38           SEC           C=1 = BREAK

      To run, load the paper tape into your Teletype reader and type

            ;  JUMPS TO JOLT/TIM