home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / zip / portfoli / tbasic.lzh / tbasic.doc < prev   
Text File  |  1991-08-21  |  25KB  |  729 lines
  1.  
  2.  
  3.  
  4.  
  5.  
  6.  
  7.                              8086 TINY BASIC USER'S GUIDE
  8.  
  9.  
  10.  
  11.  
  12.  
  13.                                      INTRODUCTION
  14.  
  15.  
  16.  
  17.               The TINY BASIC language originated in the pages  of  Dr.  DOBB'S
  18.         JOURNAL and PEOPLE'S COMPUTER COMPANY in late 1975 and early 1976. Fed
  19.         by  the  enthusiasm  of early computer hobbyists and by the challenges
  20.         and oportunities created by the early microcomputer chips, the idea of
  21.         a tiny basic interpreter quickly gained popularity and acceptance. The
  22.         language was a stripped down version  of  the  ever-popular  Dartmouth
  23.         BASIC with the proviso that it be "useful" with a minimum of then very
  24.         expensive  memory.  Additionally,  TINY  BASIC had to be ROMable since
  25.         mass storage at that time consisted of reels of teletype  punch  paper
  26.         tape,  often punched at the unbearably slow rate of ten characters per
  27.         second.  
  28.  
  29.               The TINY BASIC language supports a very limited  subset  of  the
  30.         Dartmouth  BASIC  language.  It does not compare at all with the large
  31.         floating point BASIC's that have been released for  almost  all  eight
  32.         bit  microcomputer  chips. It does not support strings. Then, why 8086
  33.         TINY BASIC? Well,  the  size  is  still  small  (2700  bytes),  it  is
  34.         efficient  and  easy  to  learn,  and it is still ROMable. All of this
  35.         implies that the language is still useful in at  least  two  important
  36.         applications: education and dedicated control.  
  37.  
  38.               The present version of TINY BASIC is  based  on  Li-Chen  Wang's
  39.         Palo  Alto  8080  TINY BASIC as published in the May 1976 issue of DR.
  40.         DOBB'S JOURNAL.  Dr. Wang's version of TINY BASIC was chosen  for  its
  41.         remarkable  resiliance  and simplicity.  It has been optimized for the
  42.         8086 and it takes advantage of the hardware multiply and  divide  that
  43.         the  8086  affords.  Other  enhancements  include  the use of the host
  44.         operating system's line editing  facilities  and  the  LOAD  and  SAVE
  45.         facilities,  which,  in  the 8080 version, are due to unknown authors.
  46.         The 8086 implementation is due to Michael  E.  Sullivan  of  Financial
  47.         Software, 54 Grove Street, Haddonfield, NJ, 08033.  
  48.  
  49.  
  50.  
  51.  
  52.                                      THE LANGUAGE
  53.  
  54.  
  55.         Numbers 
  56.  
  57.               In TINY BASIC, all number are integers and must  be  within  the
  58.         range of -32767 .. 32767.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64.                                            1
  65.  
  66.  
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73.         Variables 
  74.  
  75.               There are 26 scalar variables donoted by the letters  A  through
  76.         Z.  The  one  array  variable  is  denoted by '@(I)'. Its dimension is
  77.         limited by the size of the TINY BASIC program. See the description  of
  78.         the SIZE function.  
  79.  
  80.  
  81.         Functions 
  82.  
  83.               There are five functions in TINY BASIC.  
  84.  
  85.                ABS(X) - Returns the absolute vaulue of the variable X.
  86.         
  87.                INP(X) - Returns data read from input port X. (0<=X<=255)
  88.         
  89.                PEEK(X)- Returns the contents of memory location X. (-32767<=X<=32767)
  90.         
  91.                RND(X) - Returns a random number between 1 and X (inclusive).
  92.         
  93.                SIZE   - Returns the number of bytes left unused by the program.
  94.         
  95.  
  96.  
  97.         Arithmetic and Comparison Operators 
  98.  
  99.               The following operators are supported:  
  100.  
  101.                /   - integer divide (fractional results not returned)
  102.         
  103.                *   - integer multiply
  104.         
  105.                -   - subtract
  106.         
  107.                +   - add
  108.         
  109.                >   - compare if greater than
  110.         
  111.                <   - compare if less than
  112.         
  113.                =   - compare if equal to
  114.                        NOTE: multiple assignment statements are not supported,
  115.                              i.e., "LET A=B=O" is interpreted by TINY BASIC as
  116.                              meaning "set A to the result of comparing B with O".
  117.         
  118.                #   - compare if not equal to
  119.         
  120.                >=  - compare if greater than or equal to
  121.         
  122.                <=  - compare if less than or equal to
  123.         
  124.  
  125.         The +,-,*, and / operations return a value within the range -32767  ..
  126.         32767.  TINY BASIC works exclusively with decimal numbers. In order to
  127.         represent  the  full  range  of  numbers  between  0  and  0FFFFH  the
  128.  
  129.  
  130.                                            2
  131.  
  132.  
  133.  
  134.  
  135.  
  136.  
  137.  
  138.  
  139.         properties of two's complement arithemtic should  be  understood.  For
  140.         example,  in order to PEEK at memory location 0FFFFH, the parameter -0
  141.         should be used as the PEEK function argument.  Notice  that  the  PEEK
  142.         operation  (as  well  as  other address referenced operations) are all
  143.         relative to the current data segment, which should be the same as  the
  144.         code segment.  
  145.  
  146.               All compare operations result in a 1 if the comparison  is  true
  147.         and a 0 if it is false.  
  148.  
  149.  
  150.         Expressions 
  151.  
  152.               Expressions are formed with numbers,  variables,  and  functions
  153.         with  arithmetic and compare operators between them. + and - signs can
  154.         also be used at the beginning  of  an  expression.  The  value  of  an
  155.         expression  is  evaluated  from left to right, except that the * and /
  156.         operators are always given precedence, with +  and  -,  and  then  the
  157.         compare  operators  following, in that order.  Parentheses can be used
  158.         to alter the order of evaluation in the standard algabraic sense.  
  159.  
  160.  
  161.         Statements 
  162.  
  163.               A TINY BASIC statement consists of a statement number between  1
  164.         and  32767  followed  by  one  or  more commands (see Commands below).
  165.         Commands in the same statement are seperated by  a  semi-colon  ";".If
  166.         the  "GOTO",  "STOP", and "RETURN" commands are used then they must be
  167.         the last command in that statement.  
  168.  
  169.  
  170.         Program 
  171.  
  172.               A TINY BASIC program consists of one or  more  statements.  When
  173.         the  direct  command  (see Direct Commands below) "RUN" is issued, the
  174.         statement with the lowest statement number is executed first, then the
  175.         one with the next lowest statement number, etc. The  "GOTO",  "GOSUB",
  176.         "STOP",  and  "RETURN" commands can alter this normal sequence. Within
  177.         any statement the execution takes place from left to right.  The  "IF"
  178.         command  can  cause remaining commands within the same statement to be
  179.         skipped.  
  180.  
  181.  
  182.         Abbreviations and Blanks 
  183.  
  184.  
  185.               TINY BASIC statements and commands may use blanks freely, except
  186.         that numbers, command key words,  and  function  names  may  not  have
  187.         embedded blanks.  
  188.  
  189.               All TINY BASIC command key  words  and  function  names  may  be
  190.         abbreviated  by following the abbreviation with a period. For example,
  191.         "PR.", "PRI.", and "PRIN." all stand for  "PRINT". The word  "LET"  in
  192.         the LET command may be ommited.  
  193.  
  194.  
  195.  
  196.                                            3
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203.  
  204.  
  205.         Editor 
  206.  
  207.  
  208.               TINY BASIC contains  a  useful  text  editor  for  entering  and
  209.         correcting  TINY  BASIC  programs. All of the line editing features of
  210.         the host operating system are used. In order to  correct  an  existing
  211.         TINY  BASIC  statement,  that statement must be re-entered. Statements
  212.         may be deleted by simply typing their statement number, followed by  a
  213.         CR.  Corrections  may be verified by typing LIST nnnn and striking the
  214.         control-X key to terminate the LIST process.  
  215.  
  216.  
  217.  
  218.  
  219.                                     ERROR MESSAGES
  220.  
  221.  
  222.               There are only three error messages in TINY BASIC. When an error
  223.         is encountered the error message itself is printed,  followed  by  the
  224.         statement  causing  the program error with a "?" inserted at the point
  225.         where the error is detected.  Control is then passed to the TINY BASIC
  226.         monitor. A synopsis of the three error conditions follow.  
  227.  
  228.  
  229.         -- WHAT?
  230.         
  231.                WHAT?
  232.                210 P?TINT "THIS"
  233.  
  234.               WHAT? indicates that TINY BASIC did not understand the statement
  235.         or command.  In the example above, the command PRINT was  mistyped  on
  236.         statement number 210.  
  237.  
  238.  
  239.         -- HOW?
  240.         
  241.                HOW?
  242.                260 LET A=32000+5000?
  243.  
  244.               HOW? indicates that TINY BASIC understands  but  cannot  execute
  245.         the statement or command. In the example above, the sum of the numbers
  246.         exceeds 32767.  
  247.  
  248.  
  249.         -- SORRY
  250.         
  251.                SORRY
  252.  
  253.               SORRY indicates that TINY BASIC understand  but  cannot  execute
  254.         the  statement  or  command due to insufficient memory. One cure is to
  255.         rephrase the TINY BASIC program in acceptable abbreviations.  
  256.  
  257.  
  258.  
  259.  
  260.  
  261.  
  262.                                            4
  263.  
  264.  
  265.  
  266.  
  267.  
  268.  
  269.  
  270.  
  271.                                   STATEMENT COMMANDS
  272.  
  273.  
  274.               TINY BASIC statement commands are listed  below  with  examples.
  275.         Remember  that commands can be concatenated with semi-colons. In order
  276.         to store any given statement, you must precede that statement  with  a
  277.         statement number between 1 and 32767.  Statement numbers are NOT shown
  278.         in the examples.  
  279.  
  280.  
  281.         LET command 
  282.  
  283.                LET A=234-5*6;A=A/2;X=A-100;@(X+9)=A-1
  284.  
  285.               The LET command assigns  the  value  of  an  expression  to  the
  286.         specified  variable.    In the example above, the variable "A" assumes
  287.         the value of the expression "234-5*6", or "204". Then the variable "A"
  288.         assumes the value "102". Next, the variable "X" is set to the value of
  289.         the expression "A-100", or "2".  The last command  assigns  the  value
  290.         "101"  to  the  array  variable "@(11)".  The "LET" portion of the LET
  291.         command is optional, i.e., the following examples are true:  
  292.         
  293.                A=10
  294.                C=5*3/5;C=C*5
  295.  
  296.  
  297.         REM Command 
  298.  
  299.                REM ANYTHING CAN BE WRITTEN AFTER "REM"
  300.  
  301.               The REM command  is  ignored  by  TINY  BASIC.  It  is  used  by
  302.         experienced  programmers  to comment BASIC programs. A program comment
  303.         is used by programmers to remind themselves of the logic of a  program
  304.         section. All good programs are invariably commented.  
  305.  
  306.  
  307.         PRINT Command 
  308.  
  309.                PRINT 
  310.  
  311.               PRINT will cause a carriage-return (CR) and a line-feed (LF)  on
  312.         the output device.  
  313.  
  314.                PRINT A*3+1,"ABC" 
  315.  
  316.               This form of the PRINT command  will  print  the  value  of  the
  317.         expression  A*3+1  on the output device, followed by the string ABC on
  318.         the same line.  Note that single (') or double quotes (") may be  used
  319.         to denote character strings, but that pairs must be mached.  
  320.  
  321.                PRINT A*3+1,"ABC", 
  322.  
  323.               This form of the PRINT command will produce the same results  as
  324.         the  previous example except that the normal CR-LF is inhibited by the
  325.         trailing comma at the end of the statement. This  allows  other  PRINT
  326.  
  327.  
  328.                                            5
  329.  
  330.  
  331.  
  332.  
  333.  
  334.  
  335.  
  336.  
  337.         commands to print on the same line.  
  338.  
  339.                PRINT A,B,#3,C,D,E,#10,F,G 
  340.  
  341.               This form of the PRINT command demonstrates format control.  The
  342.         format character # is used to indicate the number of leading spaces to
  343.         be printed before a number. The default number is 6. Once the # format
  344.         is  invoked  it  is  active  for the remainder of the statement unless
  345.         overridden by a subsequent format specifier, as in the example.  
  346.  
  347.                PRINT 'ABC',\,'XXX' 
  348.  
  349.               The back-slash (\) character is used to cause a CR without a LF.
  350.         In  this example, the string ABC is printed followed by the string XXX
  351.         on top of the original ABC.  
  352.  
  353.  
  354.         INPUT Command 
  355.  
  356.  
  357.                INPUT A,B 
  358.  
  359.               The INPUT statement is used to acquire input data during program
  360.         execution.  In the example above, TINY BASIC will print  A:  and  wait
  361.         for  a  number  to  be typed at the console terminal. Next, TINY BASIC
  362.         will print B: and wait for another number to be typed at  the  console
  363.         terminal. In this example the variables A and B will assume the values
  364.         of  the  appropiate  input  values.    The INPUT statement will accept
  365.         expressions as well as numbers as input.  
  366.  
  367.                INPUT 'WHAT IS THE WEIGHT'A,"AND SIZE"B 
  368.  
  369.               In this example TINY BASIC will print the  string  WHAT  IS  THE
  370.         WEIGHT:  and  wait for operator input. Next, the string AND SIZE: will
  371.         be printed, on the same line, and TINY BASIC will  wait  for  operator
  372.         input.  
  373.  
  374.                INPUT A,'STRING',\,"ANOTHER STRING",B 
  375.  
  376.               TINY BASIC will react to the back-slash character  (\)  in  this
  377.         example in the same fashion as in the PRINT command. The second string
  378.         will overwrite the first string STRING.  
  379.  
  380.  
  381.         IF Command 
  382.  
  383.                IF A<B LET X=3;PRINT 'THIS STRING' 
  384.  
  385.               The IF command works with the comparison  operators  (enumerated
  386.         above) to check the validity of the specified comparison condition. In
  387.         this  example,  if the comparison A<B is true, then the balance of the
  388.         commands in the statement are executed.  However,  if  the  comparison
  389.         tests false, then the balance of the commands in the statement are NOT
  390.         executed  and  control  passes  to the statement with the next highest
  391.         statement number.  
  392.  
  393.  
  394.                                            6
  395.  
  396.  
  397.  
  398.  
  399.  
  400.  
  401.  
  402.  
  403.  
  404.                IF A<B GOTO 100 
  405.  
  406.               This example illustrates a common use of the IF command and  the
  407.         GOTO  (see  below)  command.  If  the comparison tests true control is
  408.         passed to statement number 100,  otherwise  execution  passes  to  the
  409.         statement with the next highest statement number.  
  410.  
  411.  
  412.         GOTO Command 
  413.  
  414.                GOTO 120 
  415.  
  416.               This  statement  is  used  to  modify  the  normal  sequence  of
  417.         execution of TINY BASIC statements. In this example, control is passed
  418.         unconditionally  to  statement  number 120. The GOTO command cannot be
  419.         followed by a semi-colon and other commands within the same statement.
  420.         It must appear as the last command in any given statement.  
  421.  
  422.                GOTO A*10+B 
  423.  
  424.               This form of the GOTO is called a "computed GOTO". In this case,
  425.         control   is  passed  to  the  statement  number  represented  by  the
  426.         expression that follows "GOTO".  
  427.  
  428.  
  429.         GOSUB Command 
  430.  
  431.                GOSUB 120 
  432.  
  433.               The GOSUB  command  is  used  to  invoke  a  subroutine  at  the
  434.         specified  statement number (120 in the example). Control is passed to
  435.         statement number 120 and execution continues. A  RETURN  command  (see
  436.         below)  is  used,  within  the subroutine, to cause TINY BASIC to pass
  437.         control to the statement that immediatly  follows  the  GOSUB  command
  438.         that  caused  the  subroutine to execute.  The GOSUB command cannot be
  439.         followed by any other commands within the same statement and  it  must
  440.         be  the last command within any given statement. GOSUB commands can be
  441.         nested, limited by the size of the stack space (see below).  
  442.  
  443.                GOSUB A*10+B 
  444.  
  445.               In this example, the subroutine at the statement number equal to
  446.         the value of the expression is executed. This form  of  the  statement
  447.         will  cause  a  different subroutine to be executed depending upon the
  448.         value of the expression that follows "GOSUB".  
  449.  
  450.  
  451.         RETURN Command 
  452.  
  453.                RETURN 
  454.  
  455.               The RETURN command causes execution to resume at  the  statement
  456.         that  follows  the  GOSUB  that  caused  the  current subroutine to be
  457.         executed. It must be the last command of any given statement.  
  458.  
  459.  
  460.                                            7
  461.  
  462.  
  463.  
  464.  
  465.  
  466.  
  467.  
  468.  
  469.  
  470.  
  471.         FOR Command 
  472.  
  473.                FOR X=1 TO 10
  474.                PRINT 'HELLO'
  475.                NEXT X
  476.  
  477.               The FOR command is used to set up execution loops. In  the  TINY
  478.         BASIC program segment above the statement PRINT 'HELLO' is executed 10
  479.         times  since  it  is  placed  between  the  FOR statement and the NEXT
  480.         statement. The  NEXT  X  statement  (see  below)  has  the  effect  of
  481.         incrementing X by one and passing control to the FOR statement. If the
  482.         new  value  of  X  is  still  less than or equal to 10, the TINY BASIC
  483.         statements between FOR and  NEXT  are  executed  again.  This  process
  484.         repeats  until X is incremented past the loop termination value (10 in
  485.         the example above).  
  486.  
  487.                FOR X=1 TO 10 STEP 2
  488.                PRINT 'HELLO'
  489.                NEXT X
  490.  
  491.               In the above variant of the FOR command the loop  increment  has
  492.         been changed from 1 (the default) to 2 by means of the STEP clause. In
  493.         this  case,  the program fragment would only print HELLO five times if
  494.         executed.  
  495.  
  496.               FOR commands can be nested, that is, one FOR  loop  can  contain
  497.         other  FOR  loops  provided that the loop variables (the variable X in
  498.         the examples) are diferent,.  If a new FOR command with the same  loop
  499.         variable  as  that  of  an old FOR command is encountered, the old FOR
  500.         will be terminated.  
  501.  
  502.  
  503.         NEXT Command 
  504.  
  505.                NEXT X 
  506.  
  507.               The NEXT command is part of the FOR command and is used to cause
  508.         loop variables to be incremented by the  increment  specified  by  the
  509.         STEP  clause (default is 1) and to pass control to the appropiate TINY
  510.         BASIC FOR loop. The variable specified by the NEXT command (X  in  the
  511.         example) is used to specify the correct FOR loop.  
  512.  
  513.  
  514.         POKE Command 
  515.  
  516.                POKE A,B 
  517.  
  518.               The POKE command is used to place data B into memory address  A.
  519.         This command may be repeated as follows:  
  520.  
  521.                POKE A,B,C,D 
  522.  
  523.         In the above example, data B is placed in memory location A, then data
  524.  
  525.  
  526.                                            8
  527.  
  528.  
  529.  
  530.  
  531.  
  532.  
  533.  
  534.  
  535.         D is placed in memory location C. All variables may be expressions. Be
  536.         careful not to POKE TINY BASIC itself!  
  537.  
  538.  
  539.         USR Command 
  540.  
  541.                USR(I,J) 
  542.  
  543.               The USR Command is actually a  built-in  TINY  BASIC  subroutine
  544.         call  that  permits  linkage to machine language subroutines. All 8086
  545.         registers are available for use by the machine language subroutine. It
  546.         is the responsibility of the machine language routine to execute a RET
  547.         instruction. In the example  above,  a  machine  language  routine  at
  548.         address I is called. J is an optional parameter that, if present, will
  549.         be passed in register BX to the subroutine.  
  550.  
  551.  
  552.         WAIT Command 
  553.  
  554.                WAIT I,J,K 
  555.  
  556.               The WAIT command is used to cause TINY BASIC execution to  pause
  557.         and  wait  for a specified value at an 8086 input port. In the example
  558.         above, the value at input port I is  read,  exclusive  OR'd  with  the
  559.         value of the expression J, and the result is then AND'd with the value
  560.         of  expression  K.  WAIT  will  return  only  if  the  final result is
  561.         non-zero. WAIT  provides an easy-to-use mechanism to cause TINY  BASIC
  562.         to  pause its execution and wait for a specified external event.  J is
  563.         assumed to be 0 if not specified.  
  564.  
  565.  
  566.         STOP Command 
  567.  
  568.                STOP 
  569.  
  570.               This command stops the execution of a  TINY  BASIC  program  and
  571.         passes  control to the TINY BASIC monitor. It can appear many times in
  572.         a program but it must be the last command in any given statement.  
  573.  
  574.  
  575.  
  576.  
  577.                                    DIRECT COMMANDS
  578.  
  579.  
  580.               Direct commands are those commands that can be invoked  only  by
  581.         the  operator  when TINY BASIC is in command mode (i.e. in response to
  582.         the '>' prompt).  All statement commands (those listed above)  can  be
  583.         invoked  while in command mode. Typing a control-C while in command or
  584.         monitor mode will cause TINY  BASIC  to  terminate.  Control  is  then
  585.         passed to the host operating system monitor.  
  586.  
  587.               Recall that a statment consists of a statement  number  followed
  588.         by  one or more commands. If the statement number is missing, or if it
  589.         is 0, the  command  will  be  executed  immediatly  after  typing  the
  590.  
  591.  
  592.                                            9
  593.  
  594.  
  595.  
  596.  
  597.  
  598.  
  599.  
  600.  
  601.         terminating CR. The following commands can be used as direct commands;
  602.         they CANNOT be used as part of a TINY BASIC statement.  
  603.  
  604.  
  605.         RUN Command 
  606.  
  607.                RUN 
  608.  
  609.               The RUN command  causes  execution  of  the  stored  TINY  BASIC
  610.         program.  Execution will commence at the lowest numbered statement and
  611.         continue until there are either no more statements  to  execute  or  a
  612.         STOP  command is found. A long TINY BASIC program may be terminated by
  613.         typing control-X at the console.  This passes  control  the  the  TINY
  614.         BASIC  monitor.  A  control-C may be typed at any time also, then TINY
  615.         BASIC is terminated and  control  is  passed  to  the  host  operating
  616.         system.  
  617.  
  618.  
  619.         LIST Command 
  620.  
  621.                LIST 
  622.  
  623.               The LIST command is used  to  display  the  current  TINY  BASIC
  624.         program  on  the  operator's console. The statements will be listed in
  625.         numerical order. If LIST is followed by an expression (e.g. LIST  200)
  626.         the  listing  will  commence  with  statements following the specified
  627.         statement, inclusive.  
  628.  
  629.  
  630.         NEW Command 
  631.  
  632.                NEW 
  633.  
  634.               The NEW command deletes the current program  from  TINY  BASIC's
  635.         memory.  
  636.  
  637.  
  638.         SAVE Command 
  639.  
  640.                SAVE FILENAME 
  641.  
  642.               The SAVE command saves the current TINY  BASIC  program  on  the
  643.         logged  in  disk  with  the  specified  filename FILENAME. The default
  644.         filetype is ".TBI".  If there is insufficient room on  the  disk,  the
  645.         SAVE command responds with "HOW?".  
  646.  
  647.  
  648.         LOAD Command 
  649.  
  650.                LOAD FILENAME 
  651.  
  652.               The LOAD command loads the specified TINY BASIC program from the
  653.         logged in disk into the program area. Any program residing within TINY
  654.         BASIC prior to the LOAD operation is lost. If the specified program is
  655.         not found on the disk, or  if  there  is  insufficient  room  for  the
  656.  
  657.  
  658.                                           10
  659.  
  660.  
  661.  
  662.  
  663.  
  664.  
  665.  
  666.  
  667.         program,  LOAD  responds  with  "HOW?".  The filetype is assumed to be
  668.         ".TBI".  
  669.  
  670.  
  671.         BYE Command 
  672.  
  673.                BYE 
  674.  
  675.               The BYE command terminates TINY BASIC. Control is passed back to
  676.         the host operating system.  
  677.  
  678.  
  679.  
  680.  
  681.                                  TINY BASIC OPERATION
  682.  
  683.  
  684.               TINY BASIC is initiated from the host operating system's command
  685.         mode like any  other  transient  command.  TINY  BASIC  will  sign-on,
  686.         announce  'OK',  and then prompt '>' awaiting operator interaction. An
  687.         example follows:  
  688.         
  689.                A:TBASIC
  690.         
  691.                8086 TINY BASIC V1.0
  692.         
  693.                OK
  694.                >
  695.         
  696.         In the example  above  the  program  'TBASIC.COM'  was  found  on  the
  697.         logged-in  disk  ('A'  in  the  example).  TINY  BASIC  then commenced
  698.         execution by first  announcing  itself  and  then  prompting  '>'  for
  699.         operator input.  
  700.  
  701.               TINY BASIC utilizes all of  the  host  operating  system's  line
  702.         editing  facilities.    For example, if an operator wished to cancel a
  703.         line typed to TINY BASIC, he need only type a control-X, etc. If  hard
  704.         copy  of a TINY BASIC session is desired, control-P and control-N will
  705.         toggle the printer, if it exists.  
  706.  
  707.               At present, saved TINY BASIC programs can be  edited  only  with
  708.         the  internal  TINY  BASIC  editor.  Programs  prepared by an external
  709.         editor can not be read by TINY BASIC.  
  710.  
  711.  
  712.  
  713.  
  714.  
  715.  
  716.  
  717.  
  718.  
  719.  
  720.  
  721.  
  722.  
  723.  
  724.                                           11
  725.  
  726.  
  727. əsupported:  
  728.  
  729.                /   - i