Subversion Repositories cpu8080

                SHERRY BROTHERS TINY BASIC VERSION 3.1

THIS IS A COPY OF LICHEN WANG'S 'PALO ALTO TINY BASIC' WHICH HAS BEEN

MODIFIED TO INCLUUDE MORE FUNCTIONS, AND DISK SAVE AND LOAD.

IT SETS IT'S SIZE TO WHATEVER SIZE YOUR SYSTEM IS, SO IT DOES NOT NEED

TO BE REASSEMBLED FOR DIFFERENT SYSTEM SIZES.

IF YOU HAVE ANY PROBLEMS WITH IT GIVE ME A CALL OR WRITE ME AND I WILL

SEE WHAT I CAN DO. HERE IS MY ADDRESS AND PHONE:

        BRUCE SHERRY

        1054 BLUEBELL DR.

        LIVERMORE, CA. 94550

        TEL (415) 443-9288

                THE LANGUAGE

NUMBERS

IN TINY BASIC, ALL NUMBERS ARE INTEGERS AND MUST BE LESS THAN 32767.

VARIABLES

THERE ARE 26 VARIABLES DENOTED BY LETTERS A THROUGH Z.  THERE IS ALSO A

SINGLE ARRAY @(I).  THE DIMENSION OF THIS ARRAY (I.E., THE RANGE OF

VALUE OF THE INDEX I) IS SET AUTOMATICALLY TO MAKE USE OF ALL THE

MEMORY SPACE THAT IS LEFT UNUSED BY THE PROGRA.  (I.E., 0 THROUGH SIZE/2,

SEE SIZE FINCTION BELOW.)

FINCTIONS

PRESENTLY THERE ARE 6 FUNCTIONS:

        ABS(X) GIVES THE ABSOLUTE VALUE OF X.

        RND(X) GIVES A RANDOM NUMBER BETWEEN 1 AND X (INCLUSIVE).

        SIZE GIVES THE NUMBER OF BYTES LEFT UNUSED BY THE PROGRAM.

                IT IS A TWO'S COMPLEMENT NUMBER SO IF IT IS

                NEGATIVE IT IS ACTUALLY LARGER THAN 32767.

        INP(X) GIVES THE VALUE (0 TO 255) OF INPUT PORT X

        PEEK(X) GIVES THE VALUE OF MEMORY LOCATION X.  TWO'S COMPLEMENT

                AGAIN.

        USR(X<,Y>) CALLS THE MACHINE LANGUAGE SUBROUTINE AT LOCATION X.

                OPTIONAL PARAMETER Y IS PASSED IN H&L IF THERE AND THE

                VALUE OF THE FUNCTION IS RETURNED IN H&L.  THE PROGRAM

                SAVES ALL REGISTERS, SO YOU DON'T HAVE TO.

ARITHMETIC AND COMPARE OPERATORS

        /       DIVIDE.  NOTE THAT SINCE WE HAVE INTEGERS ONLY, 2/3=0.

        *       MULTIPLY.

        -       SUBTRACT.

        +       ADD.

        >       COMPARE IF GREATER THAN.

        <        COMPARE IF LESS THAN.

        =       COMPARE IF EQUAL TO.  NOTE THAT TO CERTAIN VERSIONS OF

                BASIC "LET A=B=0" MEANS "SET BOTH A AND B TO 0".  TO

                THIS VERSION OF TINY BASIC, IT MEAND "SET A TO THE

                RESULT OF COMPARING B WITH 0".

        #       COMPARE IF NOT EQUAL TO.

        >=      COMPARE IF GREATER THAN OR EQUAL TO.

        <=        COMPARE IF LESS THAN OR EQUAL TO.

+, -, *, AND / OPERATIONS RESULT IN A VALUE OF BETWEEN -32767 AND

32767.  (-32768 IS ALSO ALLOWED IN SOME CASES.)  ALL COMPARE OPERATORS

RESULT IN A 1 IF TRUE AND A 0 IF NOT TRUE.

EXPRESSIONS

EXPRESSIONS ARE FORMED WITH NUMBERS, VARIABLES, AND FUNCTIONS WITH

ARITHMETIC AND COMPARE OPERATORS BETWEEN THEM.  + AND - SIGNS CAN ALSO

BE USED AT THE BEGINNING OF AN EXPRESSION.  THE VALUE OF AN

EXPRESSION IS EVALUATED FROM LEFT TO RIGHT, EXCEPT THAT * AND / ARE

ALWAYS DONE FIRST, AND THEN + AND - , AND THEN COMPARE OPERATORS.

PARENTHESES CAN ALSO BE USED TO ALTER THE ORDER OF EVALUATION.

STATEMENTS

A TINY BASIC STATEMENT CONSISTS OF A STATEMENT NUMBER BETWEEN 1 AND

32767 FOLLOWED BY ONE OR MORE COMMANDS.  COMMANDS IN THE SAME STATEMENT

ARE SEPARATED BY A SEMI-COLON ";".  "GOTO", "STOP", AND "RETURN" COMMANDS

MUST BE THE LAST COMMAND IN ANY GIVEN STATEMENT.

PROGRAM

A TINY BASIC PROGRAM CONSISTS OF ONE OR MORE STATEMENTS.  WHEN A DIRECT

COMMAND "RUN" IS ISSUED, THE STATEMENT WITH THE LOWEST STATEMENT NUMBER

IS EXECUTED FORST, THE THE ONE WITH THE NEXT LOWEST STATEMENT NUMBER, ETC.

HOWEVER, THE "GOTO", "GOSUB", "STOP", AND "RETURN" COMMANDS CAN ALTER

THIS NORMAL SEQUENCE.  WITHIN THE STATEMENT, EXECUTION OF COMMANDS IS

FROM LEFT TO RIGHT.  THE "IF" COMMAND CAN CAUSE THE EXECUTION OF ALL THE

COMMANDS TO ITS RIGHT IN THE SAME STATEMENT TO BE SKIPPED OVER.

COMMANDS

TINY BASIC COMMANDS ARE LISTED BELOW WITH EXAMPLES.  REMEMBER THAT

COMMANDS CAN BE CONCATENATED WITH SEMI-COLONS.  IN ORDER TO STORE THE

STATEMENT, YOU MUST ALSO HAVE A STATEMENT NUMBER IN FRONT OF THE

COMMANDS.  THE STATEMENT NUMBER AND THE CONCATENATION ARE NOT SHOWN

IN THE EXAMPLES.

REM OR REMARK COMMAND

REM ANYTHING GOES

THIS LINE WILL BE IGNORED BY TBI.

LET COMMAND

LET A=234-5*6, A=A/2, X=A-100, @(X+9)=A-1

WILL SET THE VARIABLE A TO THE VALUE OF THE EXPRESSION 234-5*6 (I.E. 204),

SET THE VARIABLE A (AGAIN) TO THE VALUE OF THE EXPRESSION A/2 (I.E. 102),

SET THE VARIABLE X TO THE VALUE OF THE EXPRESSION A=100 (I.E. 2), AND

THEN SET THE VARIABLE @(11) TO 101 (WHERE 11 IS THE VALUE OF THE

EXPRESSION AX+9 AND 101 IS THE VALUE OF THE EXPRESSION A-1).

LET U=A#B, V=(A>B)*X+(A

WILL SET THE VARIABLE U TO EITHER 1 OR 0 DEPENDING ON WHETHER A IS NOT

EQUAL TO OR IS EQUAL TO B; AND SET THE VARIABLE V TO EITHER X, Y OR 0

DEPENDING ON WHETHER A IS GREATER THAN, LESS THAN, OR EQUAL TO B.

PRINT COMMAND

PRINT

WILL CAUSE A CARRIAGE-RETURN (CR) AND A LINE-FEED (LF) ON THE OUTPUT

DEVICE.

PRINT A*3+1, "ABC 123 !@#", ' CBA '

WILL PRINT THE VALUE OF THE EXPRESSION A*3+1 (I.E. 307), THE STRING

OF CHARACTERS "ABC 123 !@#" AND THE STRING" CBA ", AND THEN A

CR-LF.  NOTE THAT EITHER SINGLE OR DOUBLE QUOTES CAN BE USED TO QUOTE

STRINGS, BUT PAIRS MUST BE MATCHED.

PRINT A*3+1, "ABC 123 !@#", ' CBA ',

WILL PRODUCE THE SAME OUTPUT AS BEFORE, EXCEPT THAT THERE IS NO CR-LF

AFTER THE LAST ITEM IS PRINTED,  THIS ENABLES THE PROGRAM TO CONTINUE

PRINTING ON THE SAME LINE WITH ANOTHER "PRINT".

PRINT A, B, #3, C, D, E, #10, F, G

WILL PRINT THE VALUES OF A AND B IN 6 SPACES, THE VALUES OF C, D, AND

E IN 3 SPACES, AND THE VALUES OF A AND G IN 10 SPACES.  IF THERE ARE

NOT ENOUGH SPACES SPECIFIED FOR A GIVEN VALUE TO BE PRINTED, THE VALUE

WILL BE PRINTED WITH ENOUGH SPACES ANYWAY.

PRINT 'ABC',_,'XXX'

WILL PRINT THE STRING "ABC", A CR WITHOUT A LF, AND THEN THE STRING

"XXX" (OVER THE ABC) FOLLOWED BY A CR-LF.

INPUT COMMAND

INPUT A, B

WHEN THES COMMAND IS EXECUTED, TINY BASIC WILL PRINT "A:" AND WAIT TO

READ IN AN EXPRESSION FROM THE INPUT DEVICE.  THE VARIABLE A WILL BE

SET TO THE VALUE OF THES EXPRESSION.  THEN "B:" IS PRINTED AND VARIABLE

B IS SET TO THE VALUE OF THE NEXT EXPRESSION READ FROM THE INPUT DEVICE.

NOTE THAT NOT ONLY NUMBERS, BUT ALSO EXPRESSIONS CAN BE READ AS INPUT.

INPUT 'WHAT IS THE WEIGHT'A, "AND SIZE"B

THIS IS THE SAVE AS THE COMMAND ABOVE, EXCEPT THE PROMPT "A:" IS REPLACED

BY "WHAT IS THE WEIGHT:" AND THE PROMPT "B:" IS REPLACED WITH "AND

SIZE:".  AGAIN, BOTH SINGLE AND DOUBLE QUOTES CAN BE USED AS LONG AS

THEY ARE MATCHED.

INPUT A, 'STRING',_, "ANOTHER STRING", B

THE SRINGS AND THE "_" HAVE THE SAVE EFFECT AS IN "PRINT".

OUT COMMAND

OUT 2, A+5, 6, B/7

WILL CAUSE THE LEAST SIGNIFICANT BYTE OF THE EXPRISSION "A+5" TO BE

OUTPUT TO PORT 2, AND THEN THE LEAST SIGNIFICANT BYTE OF THE EXPRESSION

"B/7" WILL BE OUTPUT TO PORT 6.

OUT X+Y,Z

THIS OUTPUTS THE VALUE OF Z (L.S. BYTE) TO THE PORT SPECIFIED BY THE

EXPRESSION "X+Y"

WAIT COMMAND

WAIT I,J

THIS READS THE STATUS OF PORT "I" AND MASKS THIS WITH "J" BY WAY OF A

"LOGICAL AND".  IT WILL CONTINUE READING UNTIL THE RESULT OF THE "AND"

IS NOT EQUAL TO ZERO.

WAIT I,J,K

THIS IS THE SAME AS BEFORE EXCEPT THAT THE STATUS IS LOGICALLY EXCLUSIVE

OR'ED WITH "K" BEFORE THE MASK TO INVERT BITS IF NECCESSARY.

POKE COMMAND

POKE 4000+X,Y

THIS COMMAND WORKS JUST LIKE OUT, EXCEPT THAT EXPRESSION "Y" IS WRITTEN

INTO MEMORY LOCATION SPECIFIED BY THE EXPRESSION "4000+X".

IF COMMAND

IF A

WILL THES THE VALUE OF THE EXPRESSION A

IS TRUE), THE COMMANDS IN THE REST OF THIS STATEMENT WILL BE EXECUTED.

IF THE VALUE OF THE EXPRESSION IS ZERO (I.E. IF IT IS NOT TRUE), THE REST

OF THIS STATEMENT WILL BE SKIPPED OVER AND EXECUTION CONTINUES AT THE

NEXT STATEMENT.  NOTE THAT THE WORD "THEN" IS NOT USED.

GOTO COMMAND

GOTO 120

WILL CAUSE THE EXECUTION TO JUMP TO STATEMENT 120.  NOTE THAT "GOTO"

COMMAND CANNOT BE FOLLOWED BY A SEMI-COLON AND OTHER COMMANDS.

IT MUST BE ENDED WITH A CR.

GOTO A*10+B

WILL CAUSE THE EXECUTION TO JUMP TO A DIFFERENT STATEMENT NUMBER AS

COMPUTED FROM THE VALUE OF THE EXPRESSION.

GOSUB AND RETURN COMMANDS

GOSUB 120

WILL CAUSE THE EXECUTION TO JUMP TO STATEMENT 120.

GOSUB A*10+B

WILL CAUSE THE EXECUTION TO JUMP TO DIFFERENT STATEMENTS AS COMPUTED

FROM THE VALUE OF THE EXPRESSION A*10+B.

RETURN

A RETURN COMMAND MUST BE THE LAST COMMAND IN A STATEMENT AND BE FOLLOWED

BY A CR.  WHEN A RETURN COMMAND IS ENCOUNTERED, IT WILL CAUSE THE EXECUTION

TO JUMP BACK TO THE COMMAND FOLLOWING THE MOST RECENT GOSUB COMMAND.

GOSUB CAN BE NESTED. THE DEPTH OF NESTING IS LIMITED ONLY BY THE STACK

SPACE.

FOR AND NEXT COMMANDS

FOR X=A+1 TO 3*B STEP C-1

THE VARIABLE X IS SET TO THE VALUE OF THE EXPRESSION A+1.  THE VALUES OF

THE EXPRESSIONS (NOT THE EXPRESSIONS THEMSELVES) 3*B AND C-1 ARE REM-

BERED.  THE NAME OF THE VARIABLE X, THE STATEMENT NUMBER AND THE

POSITION OF THIS COMMAND WITHIN THE STATEMENT ARE ALSO REMEMBERED.

EXECUTION THEN CONTINUES THE NORMAL WAY UNTIL A NEXT COMMAND IS

ENCOUNTERED.

THE STEP CAN BE POSITIVE, NEGATIVE OR EVEN ZERO.  THE WORD STEP AND THE

EXPRESSION FOLLOWING IT CAN BE OMITTED IF THE DESIRED STEP IS +1.

NEXT X

THE NAME OF THE VARIABLE (X) IS CHECKED WITH THAT OF THE MOST RECENT FOR

COMMAND.  IF THEY DO NOT AGREE, THAT FOR IS TERMINATED AND THE NEXT RECENT

FOR IS CHECKED, ETC.  WHEN A MATCH IS FOUND, THIS VARIABLE WILL BE SET TO

ITS CURRENT VALUE PLUS THE VALUE OF THE STEP EXPRESSION SAVED BY THE FOR

COMMAND.  THE UPDATED VALUE IS THEN COMPARED WITH THE VALUE OF THE TO

EXPRESSION ALSO SAVED BY THE FOR COMMAND.  IF THIS WITHIN THE LIMIT,

EXECUTION WILL JUMP BACK TO THE COMMAND FOLLOWING THE FOR COMMAND.  IF

THIS IS OUTSIDE THE LIMIT, EXECUTION CONTINUES FOLLOWING THE NEXT COMMAND

ITSELF.

FOR CAN BE NEXTED.  THE DEPTH OF NESTING IS LINITED ONLY BY THE STACK

SPACE.  IF A NEW FOR COMMAND WITH THE SAME CONTROL VARIABLE AS THAT OF AN

OLD FOR COMMAND IS ENCOUNTERED, THE OLD FOR WILL BE TERMINATED AUTOMATIC-

ALLY.

STOP COMMAND

STOP

THIS COMMAND STOPS THE EXECUTION OF THE PROGRAM AND RETURNS CONTROL TO

DIRECT COMMANDS FROM THE INPUT DEVICE.  IT CAN APPEAR MANY TIMES IN A

PROGRAM BUT MUST BE THE LAST COMMAND IN ANY GIVEN STATEMENT.  I.E. IT

CANNOT BE FOLLOWED BY A SEMI-COLON AND OTHER COMMANDS.

DIRECT COMMANDS

AS DEFINED EARLIER, A STATEMENT CONSISTS OF A STATEMENT NUMBER FOLLWOED

BY COMMANDS.  IF THE STATEMENT NUMBER IS MISSING, OR IF IT IS 0, THE

COMMANDS WILL BE EXECUTED AFTER YOU HAVE YPED THE CR.  ALL THE COMMANDS

DESCRIBED ABOVE CAN BE USED AS DIRECT COMMANDS.  THERE ARE SIX MORE

COMMANDS THAT CAN BE USED AS DIRECT COMMANDS BUT NOT AS PART OF A

STATEMENT.

RUN

WILL START TO EXECUTE THE PROGRAM STARTING AT THE LOWEST STATEMENT

NUMBER.

LIST

WILL PRINT OUT ALL THE STATEMENTS IN NUMERICAL ORDER.

LIST 120

WILL PRINT OUT ALL THE STATEMENTS IN NUMERICAL ORDER STARTING AT

STATEMENT 120.

NEW

WILL DELETE ALL THE STATEMENTS.

SAVE STARTREK

WILL SAVE THE PRESENT PROGRAM ON DISK BY WAY OF THE CPM OPERATING

SYSTEM.  IT WILL BE SAVED AS A FILE NAMED "STARTREK.TBI".  THIS

IS NOT A PURE ASCII FILE AS THE LINE NUMBERS ARE STORED IN BINARY.

LOAD STARTREK

WILL DELETE ANY PROGRAM IN MEMORY AND WILL LOAD IN A FILE FROM DISK

CALLED "STARTREK.TBI", IF IT EXISTS.

BYE

WILL RETURN YOU TO THE CPM OPERATING SYSTEM.

STOPPING THE EXECUTION

THE EXECUTION OF PROGRAM OR LISTION OF PROGRAM CAN BE STOPPED BY THE

CONTROL-C KEY ON THE INPUT DEVICE.

ABBREVIATION AND BLANKS

YOU MAY USE BLANKS FREELY, EXCEPT THAT NUMBERS, COMMAND KEY WORDS, AND

FUNCTION NAMES CANNOT HAVE EMBEDDED BLANKS.

YOU CAN TRUNCATE ALL COMMAND KEY WORDS AND FUNCTION NAMES AND FOLLOW

EACH BY A PERIOD.  "PR.", "PRI.", "PRIN." ALL STAND FOR "PRINT".

ALSO THE WORD LET IN LET COMMANDS MAY BE OMITTED.  THE "SHORTEST"

ABBREVIATION FOR ALL THE KEY WORDS ARE AS FOLLOWS:

A.=ABS          F.=FOR          GOS.=GOSUB      G.=GOTO

IF=IF           I.=INP          IN.=INPUT       L.=LIST

LO.=LOAD        N.=NEW          N.=NEXT         O.=OUTPUT

P.=PEEK         P.=POKE         PR.=PRINT       REM=REMARK

R.=RETURN       R.=RND          R.=RUN          S.=SAVE

S.=SIZE         S.=STEP         S.=STOP         TO=TO

U.=USR          W.=WAIT

NULL AND NONE-OF-THE-ABOVE = LET

ERROR REPORT

THERE ARE ONLY THREE ERROR CONDITIONS IN TINY BASIC.  THE STATEMENT WITH

THE ERROR IS PRINTED OUT WITH A QUESTION MARK INSERTED AT THE POINT

WHERE THE ERROR IS DETECTED.

(1) WHAT? MEANS IT DOES NOT UNDERSTAND YOU.  EXAMPLE:

WHAT?

260 LET A=B+3, C=(3+4?. X=4

HOW?

210 P?TINT "THIS"        WHERE PRINT IS MISSTYPED

(2) HOW? MEANS IT UNDERSTANDS YOU BUT DOES NOT KNOW HOW TO DO IT.

HOW?

310 LET A=B*C?+2           WHERE B*C IS LARGER THAN 32767

HOW?

380 GOTO 412?              WHERE 412 DOES NOT EXIST

(3) SORRY? MEANS IT UNDERSTANDS YOU AND KNOWS HOW TO DO IT BUT THERE

IS NOT ENOUGH MEMORY TO DO IT.

ERROR CORRECTIONS

IF YOU NOTICE AN ERROR IN TYPEIN BEFORE YOU HIT THE CR, YOU CAN DELETE

THE LAST CHARACTER BY THE RUB-OUT KEY OR DELETE THE ENTIRE LINE BY THE

"\" KEY.  TINY BASIC WILL ECHO A BACK ARROW "_" FOR EACH RUB-OUT.

ECHO FOR BACK-SLASH CONSISTS OF A LF, A CR, AND AN UP ARROW.

TO CORRECT A STATEMENT, YOU CAN RETYPE THE STATEMENT NUMBER AND THE

CORRECT COMMANDS.  TINY BASIC WILL TRPLACE THE OLD STATEMENT WITH THE NEW

ONE.

TO DELETE A STATEMENT, TYPE THE STATEMENT NUMBER AND A CR ONLY.

VERIVY THE CORRECTIONS BY "LIST NNNN" AND HIT THE CONTROL-C KEY WHILE

THE LINE IS BEING PRINTED.