bwBASIC/bwbasic.doc

               Bywater BASIC Interpreter, version 3.10
               ---------------------------------------------

                  Copyright (c) 1993, Ted A. Campbell
                  for bwBASIC version 2.10, 11 October 1993

                  Copyright (c) 2014-2015, Howatd Wulf, AF5NE
                  for bwBASIC version 3.00, 12 May 2015

                  Copyright (c) 2015-2016, Howatd Wulf, AF5NE
                  for bwBASIC version 3.10, 27 July 2016


CONTENTS:


   1. DESCRIPTION
   2. TERMS OF USE
   3. QUICK REFERENCE LIST OF COMMANDS, FUNCTIONS AND OPERATORS
   4. GENERAL NOTES ON USAGE
   5. PREDEFINED VARIABLES
   6. UNIMPLEMENTED COMMANDS AND FUNCTIONS
      and AGENDA FOR DEVELOPMENT
   7. THE STORY OF Bywater BASIC
   8. COMMUNICATIONS
   9. EXPANDED REFERENCE FOR COMMANDS, FUNCTIONS AND OPERATORS

   The author wishes to express his thanks to Mr. David MacKenzie, 
   who assisted in the development Unix installation and configuration
   for this version.


1. DESCRIPTION


   The Bywater BASIC Interpreter (bwBASIC) implements a large superset 
   of the ANSI Standard for Minimal BASIC (X3.60-1978) and a significant 
   subset of the ANSI Standard for Full BASIC (X3.113-1987), and many 
   classic BASIC dialects in C.  

   bwBASIC can be configured to emulate features, commands, functions 
   and operators available in many classic dialects of BASIC interpreters;
   these are controlled by the various commands.  bwBASIC does not 
   attempt bug-level compatibility with any particular BASIC dialect nor 
   does it currently support graphics.  bwBASIC seeks to be as portable 
   as possible.

   The interpreter is fairly slow.  Whenever faced with a choice
   between conceptual clarity and speed, I have consistently chosen the 
   former.  The interpreter is the simplest design available, and 
   utilizes no system of intermediate code, which would speed up 
   considerably its operation.  As it is, each line has only one 
   command.  Multi-statement lines are internally broken into distinct 
   lines as they are loaded.


2. TERMS OF USE:


   This version of Bywater BASIC is released under the terms of the 
   GNU General Public License (GPL), which is distributed with this 
   software in the file "COPYING".  The GPL specifies the terms under 
   which users may copy and use the software in this distribution.

   A separate license is available for commercial distribution,
   for information on which you should contact the author.


3. QUICK REFERENCE LIST OF COMMANDS, FUNCTIONS AND OPERATORS

   
   The OPTION VERSION command selects a specific BASIC dialect.
   A BASIC dialect is a selection of commands, functions, operators 
   and behaviors from a collection of over 500 such items.
   Additional OPTION commands are used to fine-tune the behavior.

   Note that any function can be executed as a command.  For example, 
   the function "OUT(X, Y)" can be executed as the command "OUT X, Y". 
   You can overload functions by parameter signature (the number
   and types of parameters), and user defined functions can replace
   any instrinsic function, including INP, OUT, PEEK, POKE, and WAIT.
   
      # X
      + X
      - X
      ? expressions...
      A$ LIKE B$
      APPEND filename$ | APPEND # filenumber
      AS string-variable$ [, ...]
      AUTO [start [, increment]]
      BACKSPACE # X
      BREAK line [, ...]]
      BYE
      CALL subroutine-name( [parameter [, ...] ] )
      CASE ELSE
      CASE constant [TO constant] | CASE IF partial-expression | CASE IS partial-expression
      CHAIN filename$ [, linenumber]
      CHANGE A$ TO X | CHANGE X TO A$
      CLEAR
      CLOAD [file-name$]
      CLOAD* ArrayName
      CLOSE filename$ [, ...]
      CLR
      CMDS
      COMMON variable [, ...]
      CONSOLE [WIDTH width]
      CONT
      CREATE filename$ [ RECL reclen ] AS filenum [ BUFF number ] [ RECS size ]
      CSAVE [file-name$]
      CSAVE* ArrayName
      DATA constant [, ...]
      DEF FNname[(arg...)] [= expression]
      DEF SUB
      DEFBYT letter[-letter] [, ...]
      DEFCUR letter[-letter] [, ...]
      DEFDBL letter[-letter] [, ...]
      DEFINT  letter[-letter] [, ...]
      DEFLNG letter[-letter] [, ...]
      DEFSNG letter[-letter] [, ...]
      DEFSTR letter[-letter] [, ...]
      DELETE line [- line]
      DELIMIT # X, A$
      DIM variable( elements [, ...]) [, ...]
      DO [UNTIL|WHILE expression]
      DSP variable [, ...]]
      EDIT
      ELSE
      ELSEIF
      END
      END FUNCTION
      END IF
      END SELECT
      END SUB
      ERASE variable [, ...]
      EXCHANGE variable, variable
      EXIT
      EXIT DO
      EXIT FOR
      EXIT FUNCTION
      EXIT SUB
      EXIT UNTIL
      EXIT WHILE
      FEND
      FIELD [#] device-number, number AS string-variable$ [, ...]
      FILE # X, A$
      FILES A$[, ...]
      FNCS
      FNEND
      FOR variable = start TO finish [STEP increment]
      FUNCTION [ ( parameter [, ...  ] ) ]
      GET filename$ , scalar [, ...]
      GO
      GO SUB line
      GO TO line
      GOODBYE
      GOSUB line
      GOTO line
      HELP name
      IF END # filenum THEN line1 [ELSE line2]
      IF MORE # filenum THEN line1 [ELSE line2]
      IF expression THEN
      IF expression THEN line1 [ELSE line2]
      IMAGE "format string" 
      INPUT [# device-number]|[;]["prompt string";] variable [, ...]s
      LINE INPUT [[#] device-number,]["prompt string";] string-variable$
      LIST line1 [- line2]
      LLIST line1 [- line2]
      LOAD [file-name$]
      LOOP [UNTIL|WHILE expression]
      LPRINT [USING format-string$;] expressions...
      LPRINTER [WIDTH width]
      LSET string-variable$ = expression
      MAINTAINER
      MARGIN # filenumber, width
      MAT GET filename$, arrayname
      MAT INPUT arrayname
      MAT PRINT arrayname
      MAT PUT filename$, arrayname
      MAT READ arrayname
      MAT WRITE arrayname
      MAT arrayname = expression
      MERGE file-name
      MID$( variable$, start [, count ] ) = expression
      N  = ABS( X )
      N  = ACOS( X )
      N  = ACS( X )
      N  = ACSD( X )
      N  = ACSG( X )
      N  = ANGLE( X, Y )
      N  = ARCSIN( X )
      N  = ARCTAN( X )
      N  = ARGC
      N  = ARGV( X )
      N  = ASC( A$ )
      N  = ASC( A$, X )
      N  = ASCII( A$ )
      N  = ASIN( X )
      N  = ASN( X )
      N  = ASND( X )
      N  = ASNG( X )
      N  = ATAN( X )
      N  = ATN( X )
      N  = ATND( X )
      N  = ATNG( X )
      N  = BASE
      N  = CATALOG
      N  = CATALOG( A$ )
      N  = CCUR( X )
      N  = CDBL( X )
      N  = CEIL( X )
      N  = CHDIR( A$ )
      N  = CINT( X )
      N  = CLG( X )
      N  = CLK( X )
      N  = CLNG( X )
      N  = CLOG( X )
      N  = CLOSE
      N  = CLOSE( X )
      N  = CLS
      N  = CODE( A$ )
      N  = COLOR( X, Y )
      N  = COS( X )
      N  = COSD( X )
      N  = COSG( X )
      N  = COSH( X )
      N  = COT( X )
      N  = COUNT
      N  = CSC( X )
      N  = CSH( X )
      N  = CSNG( X )
      N  = CVC( A$ )
      N  = CVD( A$ )
      N  = CVI( A$ )
      N  = CVL( A$ )
      N  = CVS( A$ )
      N  = DATE
      N  = DEF FN
      N  = DEG
      N  = DEG( X )
      N  = DEGREE
      N  = DEGREE( X )
      N  = DET
      N  = DIM( ... )
      N  = ENVIRON( A$ )
      N  = EOF( X )
      N  = EPS( X )
      N  = ERL
      N  = ERR
      N  = ERRL
      N  = ERRN
      N  = ERROR( X )
      N  = ERROR( X, A$ )
      N  = EXAM( X )
      N  = EXP( X )
      N  = FETCH( X )
      N  = FILEATTR( X, Y )
      N  = FILES
      N  = FILES( A$ )
      N  = FILL( X, Y )
      N  = FIX( X )
      N  = FLOAT( X )
      N  = FLOW
      N  = FP( X )
      N  = FRAC( X )
      N  = FRE
      N  = FRE( A$ )
      N  = FRE( X )
      N  = FREE
      N  = FREE( A$ )
      N  = FREE( X )
      N  = FREEFILE
      N  = GET( X )
      N  = GET( X, Y )
      N  = GRAD
      N  = GRADIAN
      N  = HCS( X )
      N  = HOME
      N  = HSN( X )
      N  = HTN( X )
      N  = INDEX( A$, B$ )
      N  = INITIALIZE
      N  = INP( X )
      N  = INSTR( A$, B$ )
      N  = INSTR( X, A$, B$ )
      N  = INT%( X )
      N  = INT( X )
      N  = IP( X )
      N  = KILL( A$ )
      N  = LBOUND( ... )
      N  = LEN( A$ )
      N  = LGT( X )
      N  = LN( X )
      N  = LOC( X )
      N  = LOCATE( X, Y )
      N  = LOF( X )
      N  = LOG( X )
      N  = LOG10( X )
      N  = LOG2( X )
      N  = LOGE( X )
      N  = LPOS
      N  = LTW( X )
      N  = LWIDTH( X )
      N  = MATCH( A$, B$, X )
      N  = MAX( X, Y )
      N  = MAXBYT
      N  = MAXCUR
      N  = MAXDBL
      N  = MAXDEV
      N  = MAXINT
      N  = MAXLEN( A$ )
      N  = MAXLNG
      N  = MAXLVL
      N  = MAXNUM
      N  = MAXSNG
      N  = MEM
      N  = MIN( X, Y )
      N  = MINBYT
      N  = MINCUR
      N  = MINDBL
      N  = MINDEV
      N  = MININT
      N  = MINLNG
      N  = MINNUM
      N  = MINSNG
      N  = MKDIR( A$ )
      N  = MOD( X, Y )
      N  = NAME( A$, B$ )
      N  = NOFLOW
      N  = NOTRACE
      N  = NULL( X )
      N  = NUM
      N  = NUM( A$ )
      N  = OPEN( A$, X, B$ )
      N  = OPEN( A$, X, B$, Y )
      N  = ORD( A$ )
      N  = OUT( X, Y )
      N  = PAUSE( X )
      N  = PDL( X )
      N  = PEEK( X )
      N  = PI
      N  = PI( X )
      N  = PIN( X )
      N  = POKE( X, Y )
      N  = POS
      N  = POS( A$, B$ )
      N  = POS( A$, B$, X )
      N  = POS( X )
      N  = PUT( X )
      N  = PUT( X, Y )
      N  = RAD
      N  = RAD( X )
      N  = RADIAN
      N  = RAN
      N  = RAN( X )
      N  = RANDOM
      N  = RANDOM( X )
      N  = RANDOMIZE
      N  = RANDOMIZE( X )
      N  = REMAINDER( X, Y )
      N  = RENAME( A$, B$ )
      N  = RESET
      N  = RMDIR( A$ )
      N  = RND
      N  = RND( X )
      N  = ROUND( X, Y )
      N  = SEC( X )
      N  = SEEK( X )
      N  = SEEK( X, Y )
      N  = SGN( X )
      N  = SHELL( A$ )
      N  = SIN( X )
      N  = SIND( X )
      N  = SING( X )
      N  = SINH( X )
      N  = SIZE( ... )
      N  = SIZE( A$ )
      N  = SLEEP( X )
      N  = SNH( X )
      N  = SQR( X )
      N  = SQRT( X )
      N  = STUFF( X, Y )
      N  = TAN( X )
      N  = TAND( X )
      N  = TANG( X )
      N  = TANH( X )
      N  = TI
      N  = TIM
      N  = TIM( X )
      N  = TIME
      N  = TIME( X )
      N  = TIMER
      N  = TOP
      N  = TRACE
      N  = TROFF
      N  = TRON
      N  = TRUNCATE( X, Y )
      N  = UBOUND( ... )
      N  = UNSAVE( A$ )
      N  = VAL( A$ )
      N  = VTAB( X )
      N  = WAIT( X )
      N  = WAIT( X, Y )
      N  = WAIT( X, Y, Z )
      N  = WIDTH( X )
      N  = WIDTH( X, Y )
      NAME old-file-name AS new-file-name
      NEW
      NEXT [variable]
      NOT X
      OF line, ...
      OLD [file-name$]
      ON ERROR ...
      ON ERROR GOSUB errline
      ON ERROR GOTO errline
      ON ERROR RESUME ...
      ON ERROR RESUME NEXT
      ON ERROR RETURN ...
      ON ERROR RETURN NEXT
      ON TIMER count GOSUB line
      ON expression GOTO | GOSUB line [, ...]
      OPEN file-name [FOR INPUT|OUTPUT|APPEND|BINARY|RANDOM] AS [#]device-number [LEN = record-length]
      OPTION ...
      OPTION ANGLE ...
      OPTION ANGLE DEGREES
      OPTION ANGLE GRADIANS
      OPTION ANGLE RADIANS
      OPTION ARITHMETIC
      OPTION ARITHMETIC DECIMAL
      OPTION ARITHMETIC FIXED
      OPTION ARITHMETIC NATIVE
      OPTION BASE X
      OPTION BUGS
      OPTION BUGS OFF
      OPTION BUGS ON
      OPTION COMMENT char
      OPTION COMPARE
      OPTION COMPARE BINARY
      OPTION COMPARE DATABASE
      OPTION COMPARE TEXT
      OPTION COVERAGE
      OPTION COVERAGE OFF
      OPTION COVERAGE ON
      OPTION DATE format
      OPTION DISABLE
      OPTION DISABLE COMMAND name
      OPTION DISABLE FUNCTION name
      OPTION DISABLE OPERATOR name
      OPTION ENABLE
      OPTION ENABLE COMMAND name
      OPTION ENABLE FUNCTION name
      OPTION ENABLE OPERATOR name
      OPTION ERROR
      OPTION ERROR GOSUB
      OPTION ERROR GOTO
      OPTION EXPLICIT
      OPTION IMAGE char
      OPTION IMPLICIT
      OPTION INDENT number
      OPTION LABELS
      OPTION LABELS OFF
      OPTION LABELS ON
      OPTION PRINT char
      OPTION ROUND
      OPTION ROUND BANK
      OPTION ROUND MATH
      OPTION ROUND TRUNCATE
      OPTION SLEEP number
      OPTION STATEMENT char
      OPTION STDERR filename$
      OPTION STDIN filename$
      OPTION STDOUT filename$
      OPTION STRICT
      OPTION STRICT OFF
      OPTION STRICT ON
      OPTION TERMINAL
      OPTION TERMINAL ADM
      OPTION TERMINAL ANSI
      OPTION TERMINAL NONE
      OPTION TIME format
      OPTION TRACE
      OPTION TRACE OFF
      OPTION TRACE ON
      OPTION USING string$
      OPTION VERSION [version]
      PAUSE [comment]
      POP
      PRINT [# device-number,][USING format$;] expressions ...
      PUT filename$ , value [, ...]
      QUIT
      READ variable [, ...]
      RECALL ArrayName
      REM ...
      RENAME [file-name$]
      RENUM
      RENUMBER
      RESET filename$ [, ...]
      RESTORE [line]
      RESUME [ 0 | line | NEXT ]
      RETURN
      RSET string-variable$ = expression
      RUN [line | file-name$]
      S$ = ARGT$( X )
      S$ = ARGV$( X )
      S$ = CHAR$( X )
      S$ = CHAR( X, Y )
      S$ = CHR$( X )
      S$ = CHR( X )
      S$ = CLK$
      S$ = CLK( X )
      S$ = COMMAND$( X )
      S$ = CUR( X, Y )
      S$ = DAT$
      S$ = DATE$
      S$ = DATE$( X )
      S$ = ENVIRON$( A$ )
      S$ = ERR$
      S$ = ERROR$
      S$ = HEX$( X )
      S$ = INKEY$
      S$ = INPUT$( X )
      S$ = INPUT$( X, Y )
      S$ = KEY
      S$ = KEY$
      S$ = LCASE$( A$ )
      S$ = LEFT$( A$, X )
      S$ = LEFT( A$, X )
      S$ = LIN( X )
      S$ = LTRIM$( A$ )
      S$ = MAX( A$, B$ )
      S$ = MID$( A$, X )
      S$ = MID$( A$, X, Y )
      S$ = MID( A$, X )
      S$ = MID( A$, X, Y )
      S$ = MIN( A$, B$ )
      S$ = MKC$( X )
      S$ = MKD$( X )
      S$ = MKI$( X )
      S$ = MKL$( X )
      S$ = MKS$( X )
      S$ = NUM$( X )
      S$ = OCT$( X )
      S$ = REPEAT$( X, A$ )
      S$ = REPEAT$( X, Y )
      S$ = RIGHT$( A$, X )
      S$ = RIGHT( A$, X )
      S$ = RTRIM$( A$ )
      S$ = SEG$( A$, X, Y )
      S$ = SEG( A$, X, Y )
      S$ = SPA( X )
      S$ = SPACE$( X )
      S$ = SPACE( X )
      S$ = SPC( X )
      S$ = STR$( X )
      S$ = STR( X, Y )
      S$ = STRING$( X, A$ )
      S$ = STRING$( X, Y )
      S$ = STRING( X, Y )
      S$ = TAB( X )
      S$ = TI$
      S$ = TIME$
      S$ = TIME$( X )
      S$ = TRIM$( A$ )
      S$ = UCASE$( A$ )
      SAVE [file-name$]
      SCRATCH # X
      SELECT
      SELECT CASE expression
      STEP
      STOP
      STORE ArrayName
      SUB name [ ( parameter [,...] ) ]
      SUBEND
      SWAP variable, variable
      SYSTEM
      TEXT letter[-letter] [, ...]
      THEN line1
      TIMER
      TIMER OFF
      TIMER ON
      TIMER STOP
      TLOAD [file-name$]
      TO
      TRACE OFF
      TRACE ON
      TRACE ON | OFF
      TSAVE [file-name$]
      UEND
      UNTIL expression
      USE parameter$
      USER LBL
      VARS
      WEND
      WHILE
      WRITE [# device-number,] element [, .... ]
      X # Y
      X & Y
      X * Y
      X ** Y
      X + Y
      X - Y
      X / Y
      X < Y
      X <= Y
      X <> Y
      X = Y
      X =< Y
      X => Y
      X > Y
      X >< Y
      X >= Y
      X AND Y
      X EQ Y
      X EQV Y
      X GE Y
      X GT Y
      X IMP Y
      X LE Y
      X LT Y
      X MAX Y
      X MIN Y
      X MOD Y
      X NE Y
      X OR Y
      X XOR Y
      X XRA Y
      X [ Y
      X \ Y
      X ^ Y
      [LET] variable = expression
   

4. GENERAL NOTES ON USAGE:


   4.a. Interactive Environment

   An interactive environment is provided if the flag INTERACTIVE
   is defined as TRUE in bwBASIC.h, so that a line with a
   line number can be entered at the bwBASIC prompt and it will be
   added to the program in memory.

   Line numbers are not strictly required, but are useful if the
   interactive enviroment is used for programming.  For longer
   program entry one might prefer to use an ASCII text editor, and
   in this case lines can be entered without numbers.  See also the
   documentation below for the pseudo-command EDIT, in section 5.

   4.b. Naming Conventions

   Command, function, label, and variable names are not case sensitive,
   so that "Run" and "RUN" and "run" are equivalent. 

   Variable names can use any alphabetic characters, the period
   and underscore characters and decimal digits (but not in the
   first position). They can be terminated with the various numeric 
   type characters (!,@,#,%,&,~) or the string type character ($).
   
   4.c. Numerical Constants

   Numerical constants may begin with a digit 0-9 (decimal), with
   the "&H" or "&h" (hexadecimal) or the "&o" or "&O" (octal).
   Numerical constants may include 'E' or 'e' followed by an 
   exponent number to denote exponential notation.
   Numerical constants may also be terminated by the various numeric 
   type characters (!,@,#,%,&,~), 

   4.d. Command-Line Execution

   A filename can be specified on the command line and will be
   LOADed and RUN immediately, so that the command line

      bwBASIC prog.bas

   will load and execute "prog.bas".  If a program is executed
   from the command line, control is returned to the operating system
   when the program terminates.

   4.e. Program Storage

   All programs are stored as ASCII text files.  

   4.f. TRUE and FALSE

   TRUE is defined as -1 and FALSE is defined as 0 in the default
   distribution of bwBASIC.  Alhtough these definitions can be changed 
   by those compiling bwBASIC (see file bwBASIC.H), any other values
   are not supported.

   4.g. Assignments

   Assignment must be made to variables.  This differs from some
   implementations of BASIC where assignment can be made to a
   function.  Implication: "INSTR( 3, x$, y$ ) = z$" will not
   work under bwBASIC.  The command "MID$(X$,...) = ..." is 
   implemented and should be used instead.
   
   Some BASIC dialects allow the multiple variable assignments,
   such as:
      LET A = B = C = 0
   In bwBASIC, only the left-most '=' is considered an assignment.
   All other '=' are considered comparison operators.  To resolve
   this issue, use commas to seperate the variables, such as:
      LET A, B, C = 0
   If these statements are only used to initialize the variable
   values, then they may not needed in bwBASIC, since all numeric
   variables are initialized to zero (0) and all string variables 
   are initialized to the empty string ("").

   4.h. Operators and Precedence

   The available operators are determined by the OPTION VERSION
   setting.  bwBASIC recognizes many operators, with 
   their level of precedence given in section 9.  The precedence
   levels chosen for the various operators in bwBASIC were selected 
   to be compatible with most dialects of BASIC.  If your application
   requires a specific order of evaluation, then use parentheses.
   
   The collating sequence (ASCII, EBCDIC, and so on) is determined 
   by the C compiler.  As a consequenece, the results of string
   comparisons may vary.  A simple check for collating sequence is
   shown in the following example:
   
      100 REM Purpose: Verify collating sequence (sort order)
      110 REM  Author: Howard Wulf, AF5NE
      120 REM    Date: 2015-11-28
      130 REM
      200 IF "1" < "A" THEN 300
      210 PRINT "EBCDIC"
      220 GOTO 999
      300 PRINT "ASCII"
      999 END

   4.i. Numerical Precision (NOT)

   bwBASIC utilizes numbers with only one level of precision.
   All numbers are internally represented using a C double.
   
   The various numeric type characters (!,@,#,%,&,~), 
   just like the string type character ($), are part of the 
   variable name.
     
   This version also supports type declarations, such as:
      DIM X AS INTEGER
   and
      DEF FNA(X AS INTEGER) AS INTEGER
   Combining both a type character and a type declaration
   is not supported.
   
   Type   Equivalent
   Char   declaration
   ====   ===========
   $      STRING
   #      DOUBLE
   !      SINGLE
   @      CURRENCY
   &      LONG
   %      INTEGER
   ~      BYTE

   The type declarations are used to range-check the values.  
   This allows most programs to run correctly, but does not 
   handle all possible cases.  The current implementation is not 
   complete for all possible uses of numeric type declarations.

   In the current version, the type of numeric values is used
   to select the appropriate operation.  As a consequence, 
   integer division is used when dividing two integer values.
   The MOD and \ operators use the rounded integer values of
   their parameters and return a rounded integer result.
   
   Within an expression, the result of an operation is promoted
   to the greater of:
      the type of the left parameter,
      the type of the right parameter, and
      the type required to hold the result.

   In bwBASIC, numeric constants are DOUBLE by default.  If you
   wish to coerce a numeric constant, then add the appropriate
   numeric type character immediately after the numeric digits.
   Most BASIC dialects that allow numeric constants to have a
   numeric type character adopt this convention. 
   
   4.j. OPTION VERSION and so on
   
   OPTION commands should be specified in your "profile.bas",
   so they will be effective when your BASIC program is LOADed.

   The OPTION VERSION command selects a specific BASIC dialect.
   The current list of available OPTION VERSION values are:
      OPTION VERSION Bywater          ' Bywater BASIC
      OPTION VERSION DARTMOUTH        ' Dartmouth DTSS BASIC
      OPTION VERSION MARK-I           ' GE 265 Mainframe BASIC
      OPTION VERSION MARK-II          ' GE 435 Mainframe BASIC
      OPTION VERSION SYSTEM-360       ' IBM System/360 BASIC
      OPTION VERSION RSTS-11          ' DEC RSTS-11 BASIC-PLUS
      OPTION VERSION SYSTEM-370       ' IBM System/370 BASIC
      OPTION VERSION CBASIC-II        ' CBASIC-II for CP/M
      OPTION VERSION ECMA-55          ' ANSI Minimal BASIC
      OPTION VERSION HANDBOOK1        ' The BASIC Handbook, 1st Edition
      OPTION VERSION HANDBOOK2        ' The BASIC Handbook, 2nd Edition
      OPTION VERSION TRS-80           ' TRS-80 Model I/III/4 LBASIC
      OPTION VERSION BASIC-80         ' Microsoft BASIC-80 for Xenix
      OPTION VERSION GW-BASIC         ' Microsoft GW-BASIC for MSDOS
      OPTION VERSION ECMA-116         ' ANSI Full BASIC
      OPTION VERSION QBASIC           ' Microsoft QBASIC for MSDOS
      OPTION VERSION VBX              ' Microsoft VBX for Windows

   Depending upon the current OPTION VERSION setting, certain 
   commands, functions and operators will be enabled or disabled.
   The OPTION VERSION setting also controls the default values
   for:
        OPTION STRICT ON | OFF
        OPTION ANGLE DEGREES | RADIANS | GRADIANS
        OPTION BUGS ON | OFF
        OPTION LABELS ON | OFF
        OPTION COMPARE BINARY | DATABASE | TEXT
        OPTION BASE 0 | 1
        OPTION COVERAGE ON | OFF
        OPTION TRACE ON | OFF
        OPTION ERROR GOTO | GOSUB
        OPTION COMMENT "char"
        OPTION STATEMENT "char"
        OPTION PRINT "char"
        OPTION IMAGE "char"
        OPTION DATE "format"
        OPTION TIME "format"
        OPTION USING "magic"

   As an example of the choice of OPTION VERSION:
   "OPTION VERSION ECMA-116" makes "MOD" a function, while
   "OPTION VERSION BASIC-80' makes "MOD" an operator.
   The availability of every command, function and operator
   for each "OPTION VERSION" setting is documented in section 9.

   Because OPTION VERSION changes how programs are parsed, it should be executed 
   before a BASIC program is LOADed.  The proper place to set OPTION VERSION is 
   in "profile.bas", before any other desired OPTION commands.  Note the
   version name is not quoted.
      
   Additional commands allow you to configure the available commands, 
   functions and operators to support existing BASIC programs.  They allow you
   to configure bwBASIC to support many different flavors of BASIC.

   OPTION COMMENT is provided to allow you to change the comment character.
   For example, if your existing BASIC program uses the exclamation-point as
   the comment character instead of the apostrophe, then add OPTION COMMENT "!"
   to "profile.bas", after the OPTION VERSION command.  

   OPTION IMAGE is provided to allow you to change the image character.
   For example, if your existing BASIC program uses the back-slash as
   the image character instead of the colon, then add OPTION IMAGE "\"
   to "profile.bas", after the OPTION VERSION command.  

   OPTION PRINT is provided to allow you to change the print character.
   For example, if your existing BASIC program uses the pound-sign as
   the print character instead of the question-mark, then add OPTION PRINT "#"
   to "profile.bas", after the OPTION VERSION command.  

   OPTION STATEMENT is provided to allow you to change the statement seperator
   character. For example, if your existing BASIC program uses the back-slash as
   the statement seperator character instead of the colon, then add 
   OPTION STATEMENT "\" to "profile.bas", after the OPTION VERSION command.

   OPTION DATE is provided to allow you to change the format of DATE$.
   For example, if you existing BASIC program expects the date format to be
   yyyy-mm-dd, then add OPTION DATE "%Y-%m-%d" to "profile.bas", after the
   OPTION VERSION command.  The format is used by the C function strftime().
   
   OPTION TIME is provided to allow you to change the format of TIME$.
   For example, if you existing BASIC program expects the time format to be
   HH-MM-SS, then add OPTION TIME "%H-%M-%S" to "profile.bas", after the
   OPTION VERSION command.  The format is used by the C function strftime().

   OPTION DISABLE COMMAND is provided to allow you to disable (hide) 
   a specific command.  For example, if your existing BASIC program uses
   QUIT as a variable, then add OPTION DISABLE COMMAND "QUIT" to "profile.bas",
   after the OPTION VERSION command.  
   
   OPTION DISABLE FUNCTION is provided to allow you to disable (hide) 
   a specific function.  For example, if your existing BASIC program uses
   PI as a variable, then add OPTION DISABLE FUNCTION "PI" to "profile.bas",
   after the OPTION VERSION command.

   OPTION DISABLE OPERATOR is provided to allow you to disable (hide) 
   a specific operator.  For example, if your existing BASIC program uses
   MOD as a variable, then add OPTION DISABLE OPERATOR "MOD" to "profile.bas",
   after the OPTION VERSION command.
   
   OPTION ENABLE COMMAND is provided to allow you to enable (show) 
   a specific command.  For example, if your existing BASIC program uses
   QUIT as a command, but is otherwise ECMA-55, then add 
   OPTION ENABLE COMMAND "QUIT" to "profile.bas", after the 
   OPTION VERSION command.

   OPTION ENABLE FUNCTION is provided to allow you to enable (show) 
   a specific function.  For example, if your existing BASIC program uses
   PI as a function, but is otherwise ECMA-55, then add 
   OPTION ENABLE FUNCTION "PI" to "profile.bas", after the 
   OPTION VERSION command.

   OPTION ENABLE OPERATOR is provided to allow you to enable (show) 
   a specific operator.  For example, if your existing BASIC program uses
   MOD as an operator, but is otherwise ECMA-55, then add 
   OPTION ENABLE OPERATOR "MOD" to "profile.bas", after the 
   OPTION VERSION command.
   
   OPTION ERROR GOSUB causes the program to GOSUB to the error handler.
   The error handler should exit with the RETURN command. This option
   configures the syntax of the ON ERROR command to ON ERROR GOSUB line,
   and ON ERROR RETURN NEXT.  In the current version of bwBASIC, this
   is not the default setting for any exisiting OPTION VERSION settings.
   For example, if your existing BASIC program uses ON ERROR GOSUB,
   then add OPTION ERROR GOSUB to "profile.bas", after the OPTION VERSION 
   command.  
   
   OPTION ERROR GOTO causes the program to GOTO to the error handler.
   The error handler should exit with the RESUME command.  This option
   configures the syntax of the ON ERROR command to ON ERROR GOTO line,
   and ON ERROR RESUME NEXT.  In the current version of bwBASIC, this
   is the default setting for all exisiting OPTION VERSION settings.
   For example, if your existing BASIC program uses ON ERROR GOTO,
   then add OPTION ERROR GOTO to "profile.bas", after the OPTION VERSION 
   command.  
   
   OPTION LABELS OFF disables textual labels. so statements of the form 
   "label:" and "GOTO label" are disallowed.  For example, if your existing 
   BASIC program does not use textual labels, then add OPTION LABELS OFF 
   to "profile.bas", after the OPTION VERSION command.  
   
   OPTION LABELS ON enables textual labels. so statements of the form 
   "label:" and "GOTO label" are allowed.  The label must be on a line 
   by itself and the label must end with the OPTION STATEMENT character.  
   For example, if your existing BASIC program uses textual labels, then 
   add OPTION LABELS ON to "profile.bas", after the OPTION VERSION command.  
      
   Regardless of the OPTION LABELS setting, statements of the form 
   "IF x THEN label" are not allowed, instead use the form 
   "IF x THEN GOTO label".  The reason is "IF x THEN y" is interpreted as:
       IF x THEN
         y
       END IF
   where "y" is a command, function, or subroutine.  Most BASIC dialects
   that allow textual labels adopt this convention.
   
   OPTION ROUND controls how floating point values are converted to
   whole number values.  OPTION ROUNG MATH rounds toward the nearest
   whole number, with halves rounding up to the next larger whole number,
   as commonly expected by most scientific applications.  OPTION ROUND 
   BANK rounds halves to the even whole numbers, as commonly expected 
   by most financial applications.  OPTION ROUND TRUNCATE truncates to 
   the next smaller whole number, as commonly expected by most 
   applications written for an integer BASIC.  The selected rounding 
   method is used whenever a whole number is required, including:
   a) selection value for ON ... GOTO and ON ... GOSUB
   b) any function parameter requiring a whole number
   c) array subscripts and dimensions
   d) string positions and lengths
   e) CINT() and similar
   The OPTION ROUND command does not change INT() or FIX().
   The default rounding method is OPTION ROUND BANK.

   A comparison of the different OPTION ROUND settings upon the results of CINT()
   
                                                BANK           MATH           TRUNCATE
   X              int(X)         fix(X)         cint(X)        cint(X)        cint(X)
   -2.0           -2             -2             -2             -2             -2 
   -1.6           -2             -1             -2             -2             -1 
   -1.5           -2             -1             -2             -2             -1 
   -1.4           -2             -1             -1             -1             -1 
   -1.0           -1             -1             -1             -1             -1 
   -0.6           -1              0             -1             -1              0 
   -0.5           -1              0              0             -1              0 
   -0.4           -1              0              0              0              0 
    0.0            0              0              0              0              0 
    0.4            0              0              0              0              0 
    0.5            0              0              0              1              0 
    0.6            0              0              1              1              0 
    1.0            1              1              1              1              1 
    1.4            1              1              1              1              1 
    1.5            1              1              2              2              1 
    1.6            1              1              2              2              1 
    2.0            2              2              2              2              2 

   The OPTION BUGS command determines the behavior of a number of BASIC keywords.  
   BASIC programs which rely on these behaviors are non-portable and non-standard. 
   I have considered several different names for this command, but have not yet 
   thought of a better short name.  Because OPTION BUGS changes how programs 
   are parsed, it should be executed before a BASIC program is LOADed.  The proper 
   place to set OPTION BUGS is in "profile.bas", after the OPTION VERSION command.
      
   OPTION BUGS ON disables the ANSI/ECMA/ISO standard behavior.
   With OPTION BUGS ON:
   
   FOR ...        ' values are evaluated left-to-right
   GOTO X OF ...  ' an invalid value for X falls thru without ERROR
   GOSUB X OF ... ' an invalid value for X falls thru without ERROR
   ON X GOTO  ... ' an invalid value for X falls thru without ERROR
   ON X GOSUB ... ' an invalid value for X falls thru without ERROR
   X = VAL("X")   ' returns zero without ERROR
   INPUT X        ' empty string returns zero without ERROR
   INPUT X$       ' empty string returns ""   without ERROR
   INPUT X$       ' allows unquoted character strings
   variable names ' period and underscore are allowed
   variable types ' the type characters #!@&% are allowed
   PRINT "a" X    ' string concatenation is implied
   1.2% is 1      ' the type characters #!@&% are allowed
   1D1 is ERROR   ' 'D' is not allowed as exponent seperator
   
   OPTION BUGS OFF enables the ANSI/ECMA/ISO standard behavior.
   With OPTION BUGS OFF:

   FOR ...        ' values are evaluated according to standard
   GOTO X OF ...  ' an invalid value for X is a fatal ERROR
   GOSUB X OF ... ' an invalid value for X is a fatal ERROR
   ON X GOTO  ... ' an invalid value for X is a fatal ERROR
   ON X GOSUB ... ' an invalid value for X is a fatal ERROR
   X = VAL("X")   ' raises an illegal function call (ERROR 5)
   INPUT X        ' empty string retries input
   INPUT X$       ' empty string retries input
   INPUT X$       ' unquoted character strings retries input
   variable names ' period and underscore are not allowed
   variable types ' the type characters #!@&% are not allowed
   PRINT "a";X    ' string concatenation is not implied
   1.2% is ERROR  ' the type characters #!@&% are not allowed
   1D1 is ERROR   ' 'D' is not allowed as exponent seperator

   Conflicting and pathological OPTION combinations are not supported.

   4.k. ERROR handling
   
   bwBASIC implements a simplified error handling strategy.
   Errors are seperated into two categories:
   
   a) certain errors which could be corrected with a simple 
   error handler are trappable.  These erorrs are:
   - Out of data (ERROR 4)
      - the last DATA item has already been READ.
      - the default behavior is to terminate the program.
   - Illegal function call (ERROR 5)
      - a function's parameter's value is invalid.
      - the default behavior is to terminate the program.
   - Overflow & Division by Zero  (ERROR 6)
      - the default behavior is to display a warning message.
   - Advanced Feature (ERROR 73)
      - the function is not implemented on this platform.
      - the default behavior is to terminate the program.
   If an error handler exists, then it is executed,
   otherwise the default behaivor is performed.
   The correct action to take in an error handler
   depends upon the specific application.  
   
   b) all other errors are fatal.  These errors include:
   - Syntax Error
   - FOR without NEXT
   - NEXT without FOR
   - WHILE without WEND
   - WEND without WHILE
   - and so on.
   The program is immediately terminated.

   Previous versions of bwBASIC used ON ERROR GOSUB.
   This version defaults to ON ERROR GOTO instead,
   which could depend upon the OPTION VERSION setting.  
   One solution for older bwBASIC programs is to add
   OPTION ERROR GOSUB as the first line of the program.
   Another solution would be to add OPTION ERROR GOSUB
   to your "profile.bas" file.

   4.l.  Implementation rules for functions and commands
   
   In many BASIC dialects, there are significant differences 
   between a command and a function.  In this version of bwBASIC, 
   the following rules have been used to determine whether a 
   BASIC keyword is implemented as a command or a function:
   
   a) If the keyword requires significant parsing,
   then it is implemented as a command.  An example is "PRINT".
   
   b) If the keyword requires access to variables BYREF,
   then it is implemented as a command.  An example is "SWAP".
   
   c) If the keyword changes the flow of control,
   then it is implemented as a command.  An example is "GOTO".
   
   d) A function may be used as though it were a command, 
   but a command cannot be used as though it were a function.
   
   e) The BASIC program can redefine a function, 
   but the BASIC program cannot redefine a command.  
   
   f) The BASIC program can overload a function, 
   but the BASIC program cannot overload a command.  
   
   g) Other than semantics, there is no practical difference
   between a BASIC function and a BASIC subroutine.  The
   return value of a BASIC subroutine, when called as a
   function, is zero.
   
   These rules were chosen to allow maximum flexibility, 
   while maintaining compatibility with existing BASIC programs.
   A side-effect is that a keyword you might expect to be a 
   command may have been implemented as a function.
   
   An example of the results of the above rules is "LOCATE".  
   Since "LOCATE" is implemented as a function, you may:
   a) call it as a subroutine like this:
      100 LOCATE X, Y
   b) call it as a function like this:
      100 LET N = LOCATE( X, Y ) ' N = 0
   c) redefine it as a subroutine like this:
      SUB LOCATE( X, Y )
          REM ...
      END SUB
   d) redefine it as a function like this:
      FUNCTION LOCATE( X, Y )
          REM ...
      END FUNCTION
   e) overload it using subroutines like these:
      SUB LOCATE( X, Y )
          REM ...
      END SUB
      SUB LOCATE( X, A$ )
          REM ...
      END SUB
      SUB LOCATE( A$, X )
          REM ...
      END SUB 
      SUB LOCATE( A$, B$ )
          REM ...
      END SUB 
   f) overload it using functions like these:
      FUNCTION LOCATE( X, Y )
          REM ...
      END FUNCTION
      FUNCTION LOCATE( X, A$ )
          REM ...
      END FUNCTION
      FUNCTION LOCATE( A$, X )
          REM ...
      END FUNCTION 
      FUNCTION LOCATE( A$, B$ )
          REM ...
      END FUNCTION
   
   4.m.  Reference documentation

   bwBASIC is preconfigured to support a number of specific BASIC 
   dialects which were implemented using the following references.  
   bwBASIC attempts to be compatible with the documentation below.
   bwBASIC does not attempt to be bug-level compatible, and
   bwBASIC does not implement non-portable design choices.
   There are many other good books which describe the commands, 
   functions and operators of these BASIC dialects in detail.  

   OPTION VERSION DARTMOUTH
      YEAR:
         1964
      DESCRIPTION:  
         The original BASIC dialect.
      REFERENCE:
         "BASIC"
         by Computation Center, Dartmouth College
         (c) 1964, Trustees of Dartmouth College
         http://www.bitsavers.org/pdf/dartmouth/BASIC_Oct64.pdf
      NOTES:
         The APPENDICES are implementation specific and are not supported.
         Sections 4.2 and 4.3 are implementation specific and are not supported.
         Lines containing data to be READ must have a line number and a DATA command.
         Card punch codes are not supported; use a comma or semicolon instead.
      STATUS:
         Completed.

   OPTION VERSION MARK-I
      YEAR:
         1965
      DESCRIPTION:
         BASIC dialect for the General Electric 265 Mainframe.
      REFERENCE:
         "BASIC LANGUAGE REFERENCE MANUAL"
         by Time-Sharing Service, Information Service Department, General Electric
         (c) 1965, Trustees of Dartmouth College
         http://www.bitsavers.org/pdf/ge/MarkI_Timesharing/
         202026A_BASIC_Language_Reference_Manual_Jan1967.pdf
      REFERENCE:            
         "Time-Sharing Service BASIC LANGUAGE EXTENSIONS Reference Manual"      
         by Time-Sharing Service, Information Service Department, General Electric
         (c) 1968, General Electric Company and Trustees of Dartmouth College
         http://www.bitsavers.org/pdf/ge/MarkI_Timesharing/
         802207A_Time-SharingServiceBASICLanguageExtensionsReferenceManual_Feb1968.pdf
      NOTES:
         The APPENDIXES are implementation specific and are not supported.
         MULTIPLE VARIABLE REPLACEMENT (a series of variables seperated by equal signs) 
         is not supported, so instead of this form:
            LET A=B=C=D=0
         use this form:
            LET A,B,C,D=0
         Note that the most common use of multiple variable replacement was to initialize
         a numeric variable to zero.  bwBASIC initializes all numeric variables to zero.
         CALL STATEMENT (to execute another compiled program) is not supported, 
         so instead of this form:
            CALL "PROGRAM"
         use this form:
            SHELL "PROGRAM"
         Literal values for file names are not supported (use string values instead),
         so instead of this form:
            FILES ABC.TXT,DEF.TXT,GHI.TXT
         use this form:
            FILES "ABC.TXT","DEF.TXT","GHI.TXT"
         This is a design decision to support the following:
            100 INPUT "Which file?"; A$
            110 FILE #1, A$
      STATUS:
         Completed.
      
   OPTION VERSION MARK-II
      YEAR:
         1967
      DESCRIPTION:
         BASIC dialect for the General Electric 435 Mainframe.
      REFERENCE:
         "BASIC Language Reference Manual"
         by Time-Sharing Service, Information Service Department, General Electric
         (c) 1968, General Electric Company and the Trustees of Dartmouth College
         http://www.bitsavers.org/pdf/ge/MarkI_Timesharing/
         711224A_BASICLanguageReferenceManual_Nov1970.pdf
      REFERENCE:         
         "Basic Software Library" (Volumes 1 to 8)
         by R. W. Brown
         (c) 1977, Scientific Research Inst.
      NOTES:
         The APPENDIXES are implementation specific and are not supported.
         HPS, VPS and LIN are not implemented.
         Local variables in a multiline DEF are declared using DIM.
         RESTORE* and RESTORE$ are not supported.
         Line numbers are not written to, nor read from, data files.
         FILES does not support passwords.
         Literal values for file names are not supported; use string values instead.
         This is a design decision to support the following:
            100 INPUT "Which file?"; A$
            110 FILE #1, A$
      STATUS:
         Completed.

   OPTION VERSION SYSTEM-360
      YEAR:
         1970
      DESCRIPTION:
         BASIC dialect for the IBM System/360 Mainframe.
      REFERENCE:
         "BASIC Language Reference Manual"
         by International Business Machines Corporation
         (c) 1970, International Business Machines Corporation
         http://bitsavers.org/pdf/ibm/360/os/tso/
         GC28-6837-0_BASIC_Language_Ref_Man_Jun70.pdf
      REFERENCE:
         "IBM System/360 0S(TS0) ITF:BASIC Terminal User's Guide"
         by International Business Machines Corporation
         (c) 1971, International Business Machines Corporation
         http://bitsavers.org/pdf/ibm/360/os/tso/
         SC28-6840-0_TSO_ITF_BASIC_Terminal_UG_Apr71.pdf         
      REFERENCE:         
         "CALL/360: BASIC Reference Handbook"
         by International Business Machines Corporation
         (c) 1970, The Service Bureau Corporation
         http://bitsavers.trailing-edge.com/pdf/ibm/360/os/
         call_360/CALL_360_BASIC_Reference_Handbook_1970.pdf
      NOTES:
         The APPENDIXES are implementation specific and are not supported.
         "alphabet extenders" as the first character of a variable name
         are not supported, so the following are NOT considered valid
         variable names:  @, #, $, @1, #1, $1, @@, ##, $$, and so on.
         Instead, @, # and $ are considered "type suffix characters".
         String variables, arrays, and constants may be longer than 18.
         MAT PRINT USING is not currently implemented.
         Currently, the character used for quoting a string 
         is controlled by BasicQuoteChar (in bwBASIC.h).
      STATUS:
         Completed.

   OPTION VERSION RSTS-11
      YEAR:
         1971
      DESCRIPTION:
         BASIC dialect for PDP-11 Resource Time-Sharing System (RSTS-11)
      REFERENCE:
         "PDP-11 : Resource Time-Sharing System (RSTS-11) User's Guide : BASIC-PLUS Programming Language"
         by Digital Equipment Corporation
         (c) 1971, Digital Equipment Corporation
         http://bitsavers.trailing-edge.com/pdf/dec/pdp11/rsts/
         PL-11-71-01-01-A-D_RSTS-11UsersGuide_May71.pdf
      REFERENCE:
         "BASIC-PLUS Language Manual : for use with RSTS-11 (PDP-11 Resource Time-Sharing System)"
         by Digital Equipment Corporation
         (c) 1972, Digital Equipment Corporation
         http://bitsavers.trailing-edge.com/pdf/dec/pdp11/rsts/V04/
         DEC-11-ORBPA-A-D_BASIC-PLUS_LangMan_Oct72.pdf
      REFERENCE:
         "PDP-11 : BASIC-PLUS Language Manual"
         by Digital Equipment Corporation
         (c) 1975, Digital Equipment Corporation
         http://bitsavers.trailing-edge.com/pdf/dec/pdp11/rsts/V06/
         DEC-11-ORBPB-A-D_BASIC-PLUS_LangMan_Jul75.pdf
      NOTES:
         The APPENDIXES are implementation specific and are not supported.
      STATUS:
         WORK-IN-PROGRESS.

   OPTION VERSION SYSTEM-370
      YEAR:
         1973
      DESCRIPTION:
         BASIC dialect for the IBM System/370 Mainframe.
      REFERENCE:
         "IBM Virtual Machine Facility/370: BASIC Language Reference Manual"
         by International Business Machines Corporation
         (c) 1973, International Business Machines Corporation
         http://bitsavers.trailing-edge.com/pdf/ibm/370/VM_370/Release_1/
         GC20-1803-1_VM370_BASIC_Language_Reference_Manual_Rel_1_Apr73.pdf
      NOTES:
         The APPENDIXES are implementation specific and are not supported.
         "alphabet extenders" as the first character of a variable name
         are not supported, so the following are NOT considered valid
         variable names:  @, #, $, @1, #1, $1, @@, ##, $$, and so on.
         Instead, @, # and $ are considered "type suffix characters".
         String variables, arrays, and constants may be longer than 18.
         MAT PRINT USING is not currently implemented.
         Currently, the character used for quoting a string 
         is controlled by BasicQuoteChar (in bwBASIC.h).
      STATUS:
         Completed.

   OPTION VERSION CBASIC-II
      YEAR:
         1977
      DESCRIPTION:
         BASIC dialect for CP/M.
      REFERENCE:
         "CBASIC-II"
         by Compiler Systems
         (c) 1977, Compiler Systems
         http://bitsavers.trailing-edge.com/pdf/digitalResearch/cb80/
         CBASIC_Version_2_Jan81.pdf
      REFERENCE:
         "CBASIC Language Reference Manual, 2nd Edition"
         by Diigital Research
         (c) 1982, Diigital Research
         http://bitsavers.trailing-edge.com/pdf/digitalResearch/cb80/
         CBASIC_Language_Reference_Manual_Oct82.pdf
      NOTES:
         The APPENDIXES are implementation specific and are not supported.
         The %INCLUDE directive is implemented, but only supports literal
         filesnames without drive or directory, such as:
            %INCLUDE LIBRARY.BAS            
         All other compiler directives, such as %CHAIN, are not supported.
         Note that the %INCLUDE directive is executed as a file is being LOADed, 
         and as a result the %INCLUDE does not appear in the resulting LISTing.
         Machine language functions and commands are not supported.
         The parsing of command line parameters is implementation defined.
         The specification of an array in a COMMON statement is the same as 
         the specification in a DIM statement.
         The intrinsic functions CONSTAT% and CONCHAR% are not implemented.
         The SIZE() function assumes 1024 bytes and does not support wild-cards; 
         if the file does not exist then SIZE() returns zero, otherwise SIZE() 
         returns the number of 1024 bytes blocks required to contain the file;
         an existing file of zero bytes returns a value of 1.
      STATUS:
         Completed.

   OPTION VERSION ECMA-55
      YEAR:
         1978
      DESCRIPTION:
         ANSI Minimal BASIC.  Just a document; not an actual implementation.
      REFERENCE:
         "STANDARD ECMA-55: Minimal BASIC"
         (c) 1978, EUROPEAN COMPUTER MANUFACTURERS ASSOCIATION
         http://www.ecma-international.org/publications/files/
         ECMA-ST-WITHDRAWN/ECMA-55,%201st%20Edition,%20January%201978.pdf
      NOTES:
         DIM is an executed statement in bwBASIC.  In the following 
         example the DIM statement on line 110 is not executed 
         so an ERROR occurs on line 120.
            100 GOTO 120
            110 DIM A$(100)
            120 PRINT A$(100)
         This is a design decision to support the following example.
            100 INPUT "How many?"; N
            110 DIM A$(N)
      STATUS:
         Completed.

   OPTION VERSION HANDBOOK1
      YEAR:
         1978
      DESCRIPTION: 
         Nearly every command, function and operator in all known BASIC dialects.
         This is not a specific dialect of BASIC.
         This is a convenient way to test most commands, functions and operators 
         used by mainstream BASIC dialects.
      REFERENCE:
         "The BASIC Handbook: Encyclopedia of the BASIC Computer Language"
            by David A. Lien
            1st Edition
            (c) 1978, Compusoft Publishing
            ISBN 0-932760-00-7
            364 pages
      NOTES:
         Graphic commands are not implemented.
         Abbreviated items, such as "A.", are not supported.
         The APPENDIXES are implementation specific and are not supported.
      STATUS:
         Completed.

   OPTION VERSION HANDBOOK2
      YEAR:
         1981
      DESCRIPTION:
         Nearly every command, function and operator in all known BASIC dialects.
         This is not a specific dialect of BASIC.
         This is a convenient way to test most commands, functions and operators 
         used by mainstream BASIC dialects.
      REFERENCE:
         "The BASIC Handbook: Encyclopedia of the BASIC Computer Language"
            by David A. Lien
            2nd Edition
            (c) 1981, CompuSoft Publishing
            ISBN 0-932760-05-8
            480 pages
      NOTES:
         Same notes as HANDBOOK1.
      STATUS:
         Completed.

   OPTION VERSION TRS-80
      YEAR:
         1981
      DESCRIPTION:
         BASIC dialect for the TRS-80 Model I/III/4.
      REFERENCE:
               "LBASIC USER'S GUIDE"
         (c) 1981, Galactic Software, Ltd.
         http://www.tim-mann.org/trs80/doc/lbasic.txt
      NOTES:
         For the TRS-80 Model I   use "WIDTH 16,64" in "profile.bas".
         For the TRS-80 Model III use "WIDTH 16,64" in "profile.bas".
         For the TRS-80 Model 4   use "WIDTH 24,80" in "profile.bas".
         bwBASIC requires a space around all keywords, so the LINEINPUT 
         command should be written as LINE INPUT, and so on.
         The CMD command is not supported; it is machine-specific.
         The DEFUSR command is not supported; it is machine-specific.
         The ERR function returns different values.
         The SET EOF command is not implemented.
         The USR function is not supported; it is machine-specific.
         File I/O via cassette is not supported; it is machine-specific.
         PRINT #-1 is sent to the printer.
         INPUT #-1 is an ERROR.
      STATUS:
         Completed.
      
   OPTION VERSION BASIC-80
      YEAR:
         1982
      DESCRIPTION:
         BASIC dialect for CP/M.
      REFERENCE:
         "Microsoft BASIC Reference Manual"
         (c) 1982, Microsoft
         http://chiclassiccomp.org/docs/content/computing/
         Microsoft/Microsoft_Basic_8086Xenix_Reference.pdf
      NOTES:
         The specifying double-precision values using "D" 
         instead of "E" in the exponent is not supported.
         VARPTR,USR, and hardware I/O are not implemented.
         If your application requires any of these functions:
            INP, OUT, WAIT, PEEK and POKE
         then you should implement an appropriate solution, since
         the default behavior in bwBASIC is to issue ERROR 73.
         One solution is to define the required functions 
         in your "profile.bas", returning the value your specific 
         application requires.  Following is an example.
            60000 DEF INP( X )
            60010   LET INP = 0
            60020 FNEND
            60100 DEF OUT( X, Y )
            60110   REM IGNORED
            60120 FNEND
      STATUS:
         Completed.

   OPTION VERSION GW-BASIC
      YEAR:
         1985
      DESCRIPTION:
         BASIC dialect for Microsoft DOS.
      REFERENCE:
         "Programmer's Guide: AT&T Personal Computer 6300 GWBASIC"
         by Agora Resource, Inc. Lexington, MA
         (c) 1985, by AT&T
      NOTES:
         Same notes as BASIC-80.
      STATUS:
         WORK-IN-PROGRESS.
         
   OPTION VERSION ECMA-116
      YEAR:
         1986
      DESCRIPTION:
         ANSI Full BASIC.  Just a document; not an actual implementation.
      REFERENCE:
         "STANDARD ECMA-116: Full BASIC"
         (c) 1986, EUROPEAN COMPUTER MANUFACTURERS ASSOCIATION
         http://www.ecma-international.org/publications/files/
         ECMA-ST-WITHDRAWN/ECMA-116,%201st%20edition,%20June%201986.pdf
      NOTES:
         Graphic commands are not implemented.
         Chapters 11 thru 15 are not implemented.
      STATUS:
         WORK-IN-PROGRESS.
         
   OPTION VERSION QBASIC
      YEAR:
         1991
      DESCRIPTION:
         BASIC dialect for Microsoft DOS.
      REFERENCE:
         "Differences Between GW-BASIC and QBasic"
         (c) 1991, Microsoft
         https://support.microsoft.com/en-us/kb/73084
      NOTES:
         Same notes as BASIC-80.
      STATUS:
         WORK-IN-PROGRESS.

   OPTION VERSION VBX
      YEAR:
         1992
      DESCRIPTION:
         BASIC dialect for Microsoft Windows.
      REFERENCE:
         "VBA Language Specification" (version 1.02)
         (c) 2014, Microsoft
         http://download.microsoft.com/
         download/0/A/6/0A6F7755-9AF5-448B-907D-13985ACCF53E/
         MicrosoftComputerLanguages.zip
      NOTES:
         Graphic commands are not implemented.
         Forms, controls, events, objects, DLLs, and so on are not implemented.
      STATUS:
         WORK-IN-PROGRESS.

   OPTION VERSION Bywater
      YEAR:
         2015
      DESCRIPTION:
         Bywater BASIC
      REFERENCE:
         This document.
      NOTES:
         This is a combination of many BASIC dialects,
         with many commands, functions and operators.
         Graphic commands are not implemented.
      STATUS:
         Completed.


5. PREDEFINED VARIABLES


   BWB.EDITOR$
   BWB.FILES$
   BWB.PROMPT$
   BWB.IMPLEMENTATION$

   The commands EDIT and FILES are pseudo-commands that launch
   shell programs named in the variables BWB.EDITOR$ and BWB.FILES$,
   respectively.  The default values for these variables can
   be changed in bwBASIC.h (DEF_EDITOR and DEF_FILES), or they
   can be changed on the fly by the user.  An idea might be to
   initialize these variables in "profile.bas" for specific
   implementations; for instance, BWB.FILES$ might be defined as
   "ls -l" on Unix systems or "dir" on DOS systems.

   The preset variable BWB.PROMPT$ can be used to set the prompt
   string for bwBASIC.  Again, it is suggested that a user-
   selected prompt can be set up in a "profile.bas" to be
   initialized each time bwBASIC starts.  Note that special
   characters can be added to the prompt string, e.g.,

      BWB.PROMPT$ = "Ok"+CHR$(10)

   will give an "Ok" prompt followed by a linefeed.

   The preset variable BWB.IMPLEMENTATION$ will return "TTY" (IMP_IDSTRING)
   for the bwx_tty implementation.  In previous versions of bwBASIC,
   the existance of the keywords CLS, COLOR and LOCATE were determined 
   at compile and BWB.IMPLEMENTATION$ was used at runtime to determine
   whether these keywords existed.  In the current version,
   these keywords always exist and are now controlled at runtime 
   using the OPTION TERMINAL commands.  With OPTION TERMINAL NONE
   these keywords output nothing.     

   
6. UNIMPLEMENTED COMMANDS AND FUNCTIONS, and AGENDA FOR DEVELOPMENT


   There are some items not implemented that have been so long
   a part of some BASICs that their absence will seem surprising.
   In each case, though, their implementation would require opera-
   ting-system-specific functions or terminal-specific functions
   that cannot be universally provided. Some specific examples:


   INP reads a value from a hardware port.  In the current version,
   using INP() will generate ERROR 73 on most platforms.  It is
   expected that you will provide a suitable implementation for your 
   specific application. For example:
       FUNCTION INP( X )
           REM Return whatever value your application requires
           INP = 0
       END FUNCTION

   OUT writes a value to a hardware port.  In the current version,
   using OUT() will generate ERROR 73 on most platforms.  It is
   expected that you will provide a suitable implementation for your 
   specific application. For example:
       SUB OUT( X, Y )
           REM do something
       END SUB

   PEEK reads a value from a memory location.  In the current version,
   using PEEK() will generate ERROR 73 on most platforms.  It is
   expected that you will provide a suitable implementation for your 
   specific application. For example:
       FUNCTION PEEK( X )
           REM Return whatever value your application requires
           PEEK = 0
       END FUNCTION
         
   POKE writes a value to a memory location.  In the current version,
   using POKE() will generate ERROR 73 on most platforms.  It is
   expected that you will provide a suitable implementation for your 
   specific application. For example:
       SUB POKE( X, Y )
           REM do something
       END SUB

   WAIT reads a value from a hardware port.  In the current version,
   using WAIT() will generate ERROR 73 on most platforms.  It is
   expected that you will provide a suitable implementation for your 
   specific application. For example:
       SUB WAIT( X, Y )
           REM do something
       END SUB
       SUB WAIT( X, Y, Z )
           REM do something
       END SUB

   DEF USR, USR and VARPTR rely on hardware-specific conventions.
   The only fix is to remove them from your BASIC program. 

   There are other commands, functions, and implementation details
   that I am working on, and which are on the agenda list for future
   versions of bwBASIC.  These agenda include:
      
   PARACT i.e., the ability to execute PARallel ACTions. This
     is described in ANSI BASIC, although I have not seen it
     implemented before.  It will offer a rough, non-
     preemptive form of multitasking within the scope
     of a BASIC program. Programmers will note points at which
     there are already hooks for PARACT in bwBASIC.
     In the interim, you might use the "ON TIMER" command to
     implement a simple multitasking BASIC program.

   XMEM  PC-type computers need to be able to use extended
     memory.  If we could use extended memory for program
     lines, variables, and function defitions, we could
     write much longer programs.  This would entail,
     however, a fairly serious rewriting of the program
     to utilize memory handles for these storage features
     instead of direct memory pointers.  In the interim,
     you might use a "DOS Extender" which hooks calloc()
     and free() to enable transparent access to EMS or XMS 
     memory.

   Windows The addition of memory handles in addition to the
     non-preemptive execution of program lines (in a
     crude form, already present) will make it possible
     to develop implementations for Windows and perhaps
     for other graphical user interfaces.  But what form
     should this take?  I have in mind presently a BASIC
     that would run in the background, appearing only
     as an icon in the GUI space, with pop-up editors
     and output windows. Thus, the interpreted language
     would serve a purpose something like 'cron' (a task
     scheduler) under Unix systems. You may have some
     reflections that would help me in this.  

   Graphics  Here we face fairly critical differences in different
     styles and implementations of graphics, e.g., between
     GWBASIC, ANSI BASIC, VisualBASIC, etc. But it's
     possible that Graphics commands and functions could
     be added.  These would all be OPTION VERSION specific.
     In the interim, you might consider using ReGIS or Tektronix
     graphics (ESC codes) with xterm.

   The ANSI Standard for full BASIC does not specify which particular
   commands or functions must be implemented, and in fact the standard
   is very robust.  Perhaps no implementation of BASIC would ever
   include all of the items, but some ANSI commands and functions which
   remain unimplemented are:

   ACCESS
   AREA
   ARRAY
   ASK
   BSTR
   BVAL
   CELLS
   CLIP
   COLLATE
   CONNECT
   DATUM
   DEBUG
   DECLARE
   DEVICE
   DISCONNECT
   DISPLAY
   DOT
   DRAW
   ERASE
   EVENT
   EXCEPTION
   GRAPH
   HANDLER
   IMAGE
   KEY
   LINES
   MIX
   MULTIPOINT
   OUTIN
   OUTPUT
   PARACT
   PICTURE
   PIXEL
   PLOT
   POINTS
   RECEIVE
   RENUMBER
   REWRITE
   ROTATE
   SEIZE
   SEND
   SHIFT
   TIMEOUT
   TRACE
   TRANSFORM
   VIEWPORT
   WAIT
   VIEWPORT
   ZONEWIDTH


7. THE STORY OF Bywater BASIC


   This program was originally begun in 1982 by my grandmother, Mrs.
   Verda Spell of Beaumont, TX.  She was writing the program using
   an ANSI C compiler on an Osborne I CP/M computer and although my
   grandfather (Lockwood Spell) had bought an IBM PC with 256k of
   RAM my grandmother would not use it, paraphrasing George Herbert
   to the effect that "He who cannot in 64k program, cannot in 512k."
   She had used Microsoft BASIC and although she had nothing against
   it she said repeatedly that she didn't understand why Digital
   Research didn't "sue the socks off of Microsoft" for version 1.0
   of MSDOS and so I reckon that she hoped to undercut Microsoft's
   entire market and eventually build a new software empire on
   the North End of Beaumont. Her programming efforts were cut
   tragically short when she was thrown from a Beaumont to Port
   Arthur commuter train in the summer of 1986. I found the source
   code to bwBASIC on a single-density Osborne diskette in her knitting
   bag and eventually managed to have it all copied over to a PC
   diskette. I have revised it slightly prior to this release. You
   should know, though, that I myself am an historian, not a programmer.


8. COMMUNICATIONS:


   email:  tcamp@delphi.com


9. EXPANDED REFERENCE FOR COMMANDS, FUNCTIONS AND OPERATORS

   
   bwBASIC provides a simple "HELP" command to assist you in
   finding the command or function you are looking for.
   If you do not find the command you are looking for,
   then look to see if it has been implemented as a function.

   This section provide brief descriptions of every intrinsic 
   command, function and operator available in bwBASIC; 
   it is not intented to be an exhaustive reference.

   Please refer to the reference documentation in section 4.m
   for detailed descriptions of each of the following items.


============================================================
                    COMMANDS                                
============================================================


------------------------------------------------------------
     SYNTAX: ? expressions...
DESCRIPTION: This is just a shortcut for PRINT.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: APPEND filename$ | APPEND # filenumber
DESCRIPTION: APPEND filename$ Merges the BASIC program in file-name
             into the current BASIC program; lines in filename$ replace any
             matching lines in the current program.  APPEND # positions filenumber
             at EOF and sets the file to writing; filenumber <= 0 is ignored.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: AS string-variable$ [, ...]
DESCRIPTION: AS by itself is a Syntax Error.  Use FIELD ... AS
             instead.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: AUTO [start [, increment]]
DESCRIPTION: Automatic line numbering for manual program entry.
             If the line already exists, then an asterisk is displayed and
             pressing ENTER leaves the line as-is.  If the line does not exist,
             then an asterisk is not displayed and pressing ENTER terminates
             AUTO mode.  Regardless of the line's existance, entering the
             command MAN will terminate AUTO mode.  AUTO mode is also terminated
             by any ERROR or by pressing control-C.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: BACKSPACE # X
DESCRIPTION: Points the file to the previous item.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: BREAK line [, ...]]
DESCRIPTION: Diagnostic command to stop execution at the specified
             line(s).  BREAK only applies to user-numbered lines.  For multi-statement
             lines, BREAK only applies to the first statement.  BREAK effectively
             inserts a hidden STOP command immediately after the line number.
             Once a BREAK occurrs on a specified line, it is automatically
             removed.  To remove all existing BREAKs, execute BREAK without
             any line numbers.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: BYE
DESCRIPTION: Exits to the operating system.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: CALL subroutine-name( [parameter [, ...] ] )
DESCRIPTION: Calls a subroutine that was defined by SUB and END
             SUB.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: CASE constant [TO constant] | CASE IF partial-expression | CASE IS partial-expression
DESCRIPTION: Introduces an element of a SELECT CASE statement.
             Multiple tests must be seperated a comma.  For example:  CASE
             1, 2 TO 3, IS > 4, IF < 5
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: CASE ELSE
DESCRIPTION: Introduces a default SELECT CASE element.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: CHAIN filename$ [, linenumber]
DESCRIPTION: Load and execute another BASIC program, without
             clearing common variables.  For System/370, the syntax is CHAIN
             filename$,parameter$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: CHANGE A$ TO X | CHANGE X TO A$
DESCRIPTION: Changes a string to a numeric array or a numeric
             array to a string.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: CLEAR
DESCRIPTION: Sets all numeric variables to 0, and all string
             variables to empty strings.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: CLOAD [file-name$]
DESCRIPTION: Loads an ASCII BASIC program into memory.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: CLOAD* ArrayName
DESCRIPTION: Loads a numeric array from a file saved using CSAVE*.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: CLOSE filename$ [, ...]
DESCRIPTION: Closes an input or output file.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: CLR
DESCRIPTION: Sets all numeric variables to 0, and all string
             variables to empty strings.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: CMDS
DESCRIPTION: Prints a list of all implemented BASIC commands.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: COMMON variable [, ...]
DESCRIPTION: Designates variables to be passed to a CHAINed program.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: CONSOLE [WIDTH width]
DESCRIPTION: Directs the output of PRINT commands to the console
             (stdout), and optionally changes the console width.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: CONT
DESCRIPTION: Continue a BASIC program after a STOP has been executed.
             Program resumes at the line after the STOP.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: CREATE filename$ [ RECL reclen ] AS filenum [ BUFF number ] [ RECS size ]
DESCRIPTION: Creates the file and opens it.  If the file already
             exists, then it is ereased.  If the file cannot be created, then
             an error occurs.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: CSAVE [file-name$]
DESCRIPTION: Saves the current program into the file file-name$
             in ASCII format.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: CSAVE* ArrayName
DESCRIPTION: Saves a numeric array into a file for later loading
             by CLOAD*.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: DATA constant [, ...]
DESCRIPTION: Stores numeric and string constants to be accessed
             by READ.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DEF FNname[(arg...)] [= expression]
DESCRIPTION: Defines a user-written function.  Single line DEF
             functions use '= expression'.  Multiple line DEF functions do
             not use '= expression' and must end with FNEND.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DEF SUB
DESCRIPTION: An internal command that allows the BASIC program
             to execute any function as though it were a command.  You do
             not directly call this command.  If your program has a line 
             beginning with a functio name, then DEF SUB is used to execute
             the function and ignore the result.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DEFBYT letter[-letter] [, ...]
DESCRIPTION: Declares variables with single-letter names as numeric
             variables.  TODO: enforce the range of [MINBYT,MAXBYT].
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DEFCUR letter[-letter] [, ...]
DESCRIPTION: Declares variables with single-letter names as numeric
             variables.  TODO: enforce the range of [MINCUR,MAXCUR].
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DEFDBL letter[-letter] [, ...]
DESCRIPTION: Declares variables with single-letter names as numeric
             variables.  TODO: enforce the range of [MINDBL,MAXDBL].
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DEFINT  letter[-letter] [, ...]
DESCRIPTION: Declares variables with single-letter names as numeric
             variables.  TODO: enforce the range of [MININT,MAXINT].
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DEFLNG letter[-letter] [, ...]
DESCRIPTION: Declares variables with single-letter names as numeric
             variables.  TODO: enforce the range of [MINLNG,MAXLNG].
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DEFSNG letter[-letter] [, ...]
DESCRIPTION: Declares variables with single-letter names as numeric
             variables.  TODO: enforce the range of [MINSNG,MAXSNG].
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DEFSTR letter[-letter] [, ...]
DESCRIPTION: Declares variables with single-letter names as string
             variables.  TODO: enforce the range of [MINLEN,MAXLEN].
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DELETE line [- line]
DESCRIPTION: Deletes program lines indicated by the argument(s).
             All program lines have a number, which is visible with the LIST
             command.  If line numbers are not provided, they are assigned
             beginning with 1.  Deleting a non-existing line does not cause
             an error.  For CBASIC-II, the syntax is DELETE filenumber.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DELIMIT # X, A$
DESCRIPTION: Sets the delimiter for READ # and WRITE #.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: DIM variable( elements [, ...]) [, ...]
DESCRIPTION: Specifies the dimensions of an array variables.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DO [UNTIL|WHILE expression]
DESCRIPTION: Top of a DO - LOOP structure.  DO: If the loop is
             not terminated by EXIT DO or LOOP UNTIL or LOOP WHILE, then it
             will loop forever.  DO UNTIL: exits when non-zero.  DO WHILE:
             exits when zero.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: DSP variable [, ...]]
DESCRIPTION: Diagnostic command to display the value every time
             the variable is assigned.  To remove all existing DSPs, execute
             DSP without any variables.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: EDIT
DESCRIPTION: implementation defined.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: ELSE
DESCRIPTION: Introduces a default condition in a multi-line IF
             statement.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: ELSEIF
DESCRIPTION: Introduces a secondary condition in a multi-line
             IF statement.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: END
DESCRIPTION: Terminates program execution. If the BASIC program
             was executed from the operating system level, then control returns
             to the operating system, oterwise control reuturns to the BASIC
             prompt.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: END FUNCTION
DESCRIPTION: Specifies the last line of a multi-line FUNCTION
             definition.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: END IF
DESCRIPTION: Specifies the last line of a multi-line IF definition.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: END SELECT
DESCRIPTION: Specifies the last line of a multi-line SELECT CASE
             definition.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: END SUB
DESCRIPTION: Specifies the last line of a multi-line SUB definition.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: ERASE variable [, ...]
DESCRIPTION: Eliminates arrayed variables from a program.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: EXCHANGE variable, variable
DESCRIPTION: Swaps the values of two variables. Both variables
             must be of the same type.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: EXIT
DESCRIPTION: EXIT by itself is a Syntax Error.  Use EXIT DO,
             EXIT FOR, EXIT FUNCTION, EXIT SUB, EXIT UNTIL, or EXIT WHILE
             instead.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: EXIT DO
DESCRIPTION: Immediately exits the inner-most DO-LOOP strucure.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: EXIT FOR
DESCRIPTION: Immediately exits the inner-most FOR-NEXT strucure.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: EXIT FUNCTION
DESCRIPTION: Immediately exits the inner-most multi-line FUNCTION
             strucure.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: EXIT SUB
DESCRIPTION: Immediately exits the inner-most multi-line SUB
             strucure.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: EXIT UNTIL
DESCRIPTION: Immediately exits the inner-most UNTIL-UEND strucure.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: EXIT WHILE
DESCRIPTION: Immediately exits the inner-most WHILE-END strucure.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: FEND
DESCRIPTION: Specifies the last line of a multi-line DEF function.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: FIELD [#] device-number, number AS string-variable$ [, ...]
DESCRIPTION: Assigns 'number' bytes in the buffer of random file
             'device-number' to the variable 'string-variable$'.  GET will
             automatically update the variable, and PUT will automatically
             use the variable.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: FILE # X, A$
DESCRIPTION: If A$ is '*' then closes file # X.  If A$ is not
             '*' then opens the file named A$ in READ mode.  For CBASIC-II,
             the syntaxis FILE filename$ [( reclen )].
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: FILES A$[, ...]
DESCRIPTION: If A$ is not '*' opens the file named A$ in READ
             mode.  The first filename of the first FILES command is assocated
             with file number 1.  Note that multiple FILES commands accumulate.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: FNCS
DESCRIPTION: Prints a list of all pre-defined BASIC functions.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: FNEND
DESCRIPTION: Specifies the last line of a multi-line DEF function.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: FOR variable = start TO finish [STEP increment]
DESCRIPTION: Top of a FOR - NEXT structure.  The loop will continue
             a fixed number of times, which is determined by the values of
             start, finish, and increment.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: FUNCTION [ ( parameter [, ...  ] ) ]
DESCRIPTION: Top line of a multi-line FUNCTION definition.  The
             variable names specified are local to the FUNCTION definition,
             and are initialized BYVAL when the function is invoked by another
             routine.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: GET filename$ , scalar [, ...]
DESCRIPTION: Gets one (or more) values from a file.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: GO
DESCRIPTION: GO by itself is a syntax error.  Use GOTO or GOSUB
             instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: GO SUB line
DESCRIPTION: Initiates a subroutine call to the line specified.
             The subroutine must end with RETURN.  The 'line' may be a number
             or a label.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: GO TO line
DESCRIPTION: Branches program execution to the specified line.
             The 'line' may be a number or a label.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: GOODBYE
DESCRIPTION: Exits to the operating system.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: GOSUB line
DESCRIPTION: Initiates a subroutine call to the line specified.
             The subroutine must end with RETURN.  The 'line' may be a number
             or a label.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: GOTO line
DESCRIPTION: Branches program execution to the specified line.
             The 'line' may be a number or a label.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: HELP name
DESCRIPTION: Provides help on the specified 'name' which is a
             command name or function name.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: IF expression THEN line1 [ELSE line2]
DESCRIPTION: Single line standard IF command.  If the value of
             expression is non-zero, then branh to line1.  If the value of
             expression is zero and ELSE is provided, then branch to line2.
             Otherwise continue to the next line.  LABELS are not allowed.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: IF END # filenum THEN line1 [ELSE line2]
DESCRIPTION: Single line standard IF command.  If the file is
             at EOF , then branch to line1.  If the file is not at EOF and
             ELSE is provided, then branch to line2.  Otherwise continue to
             the next line.  LABELS are not allowed.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: IF MORE # filenum THEN line1 [ELSE line2]
DESCRIPTION: Single line standard IF command.  If the file is
             not at EOF , then branch to line1.  If the file is at EOF and
             ELSE is provided, then branch to line2.  Otherwise continue to
             the next line.  LABELS are not allowed.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: IF expression THEN
DESCRIPTION: Top of a multi-line IF - END IF structure.  If the
             value of expression is non-zero, then the program lines upto
             the next ELSE or ELSE IF command are executed, otherwise the
             program branches to the next ELSE or ELSE IF command.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: IMAGE "format string" 
DESCRIPTION: Provides format string for PRINT USING line-number.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: INPUT [# device-number]|[;]["prompt string";] variable [, ...]s
DESCRIPTION: Reads input from the terminal or the file specified
             by device-number.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: [LET] variable = expression
DESCRIPTION: Assigns the value of expression to variable.  The
             'LET' keyword is optional.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: LINE INPUT [[#] device-number,]["prompt string";] string-variable$
DESCRIPTION: Reads entire line from the keyboard or a file into
             string-variable$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: LIST line1 [- line2]
DESCRIPTION: Lists BASIC program lines from 'line1' to 'line2'
             to stdout.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: LLIST line1 [- line2]
DESCRIPTION: Lists BASIC program lines from 'line1' to 'line2'
             to the default printer on stderr.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: LOAD [file-name$]
DESCRIPTION: Loads an ASCII BASIC program into memory.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: LOOP [UNTIL|WHILE expression]
DESCRIPTION: Bottom of a DO - LOOP structure.  LOOP:  IF the
             loop is not terminated by EXIT DO or DO UNTIL or DO WHILE, then
             it will loop forever.  LOOP UNTIL:  exits when expression is
             nonz-zero.  LOOP WHILE:  exits when expression is zero.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: LPRINT [USING format-string$;] expressions...
DESCRIPTION: Send output to the default printer(stderr).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [X] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: LPRINTER [WIDTH width]
DESCRIPTION: Directs the output of PRINT commands to the printer
             (stderr), and optionally changes the printer width.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: LSET string-variable$ = expression
DESCRIPTION: Left-aligns the value of expression into string-variable$.
             If the length of the value is too short, then it is padded on
             the right with spaces.  If the length of the value is too long,
             then it is truncated on the right.  This is only for use with
             variables assigned to a random access buffer with FIELD command.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: MAINTAINER
DESCRIPTION: This command is reserved for use by the Bywater
             BASIC maintainer and does whatever the maintainer wants it to
             do.  It is not for the BASIC programmer.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: MARGIN # filenumber, width
DESCRIPTION: Sets the file margin for writing; filenumber <=
             0 is ignored.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: MAT arrayname = expression
DESCRIPTION: Matrix operations:  MAT A = CON, MAT A = IDN, MAT
             A = ZER, MAT A = INV B, MAT A = TRN B, MAT A = (k) * B, MAT A
             = B, MAT A = B + C, MAT A = B - C, MAT A = B * C. 
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: MAT GET filename$, arrayname
DESCRIPTION: Matrix get.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: MAT INPUT arrayname
DESCRIPTION: Matrix input.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: MAT PRINT arrayname
DESCRIPTION: Matrix print.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: MAT PUT filename$, arrayname
DESCRIPTION: Matrix put.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: MAT READ arrayname
DESCRIPTION: Matrix read.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: MAT WRITE arrayname
DESCRIPTION: Matrix write.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: MERGE file-name
DESCRIPTION: Merges the BASIC program in file-name into the current
             BASIC program.  Lines in file-name replace any matching lines
             in the current program.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: MID$( variable$, start [, count ] ) = expression
DESCRIPTION: Replaces a subtring of variable$ with expression.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: NAME old-file-name AS new-file-name
DESCRIPTION: Changes the name of an existing file.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: NEW
DESCRIPTION: Deletes the program in memory and clears all variables.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: NEXT [variable]
DESCRIPTION: The bottom line of a FOR - NEXT structure.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OF line, ...
DESCRIPTION: OF by itself is a Syntax Error.  Use GOTO ... OF
             instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OLD [file-name$]
DESCRIPTION: Loads an ASCII BASIC program into memory.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: ON expression GOTO | GOSUB line [, ...]
DESCRIPTION: Branches (GOTO) or calls (GOSUB) based on the rounded
             value of variable.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: ON ERROR ...
DESCRIPTION: ON ERROR  by itself is a syntax error.  Use ON ERROR
             GOSUB or ON ERROR GOTO instead.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: ON ERROR GOSUB errline
DESCRIPTION: When a trappable error occurs, execute 'GOSUB errline'.
             The error handler must terminate with a RETURN command.  If
             the line number is 0 (zerp), then use the default error handler.
             Valid when OPTION ERROR GOSUB.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: ON ERROR GOTO errline
DESCRIPTION: When a trappable error occurs, execute 'GOTO errline'.
             The error handler must terminate with a RESUME command.  If
             the line number is 0 (zerp), then use the default error handler.
             Valid when OPTION ERROR GOTO.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: ON ERROR RESUME ...
DESCRIPTION: ON ERROR RESUME by itself is a syntax error.  Use
             ON ERROR RESUME NEXT instead.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: ON ERROR RESUME NEXT
DESCRIPTION: When a trappable error occurs, execution continues
             with the next line.  Valid when OPTION ERROR GOTO.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: ON ERROR RETURN ...
DESCRIPTION: ON ERROR RETURN by itself is a syntax error.  Use
             ON ERROR RETURN NEXT instead.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: ON ERROR RETURN NEXT
DESCRIPTION: When a trappable error occurs, execution continues
             with the next line.  Valid when OPTION ERROR GOSUB.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: ON TIMER count GOSUB line
DESCRIPTION: Specifies a line (or label) to gosub when count
             seconds have elaspsed after TIMER ON is executed.  The interrupt
             routine should end with a RETURN command.  Timer events only
             occur in running BASIC programs.  The resolution of the clock
             is implementation defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: OPEN file-name [FOR INPUT|OUTPUT|APPEND|BINARY|RANDOM] AS [#]device-number [LEN = record-length]
DESCRIPTION: Opens a file for use.  INPUT, OUTPUT, and APPEND
             are for text files.  BINARY is for binary files.  RANDOM is for
             structured binary files and requires LEN.  Files opened for RANDOM
             use GET and PUT.  For CBASIC-II, this opens an existing file
             and the syntax is OPEN filename$ [ RECL reclen ] AS filenum [
             BUFF number ] [ RECS size ].
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ...
DESCRIPTION: OPTION by itself is a syntax error.  Use one of
             the many OPTION commands instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ANGLE ...
DESCRIPTION: OPTION ANGLE by itself is a syntax error.  Use OPTION
             ANGLE DEGREES, OPTION ANGLE GRADIANS, or OPTION ANGLE RADIANS
             instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ANGLE DEGREES
DESCRIPTION: Configures these math functions to accept and return
             angles in degrees:  ACOS, ACS, ANGLE, ARCSIN, ASIN, ASN, ARCTAN,
             ATN, ATAN, COS, COT, CSC, SEC, SIN and TAN.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ANGLE GRADIANS
DESCRIPTION: Configures these math functions to accept and return
             angles in gradians:  ACOS, ANGLE, ASIN, ASN, ATN, ATAN, COS,
             COT, CSC, SEC, SIN and TAN.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ANGLE RADIANS
DESCRIPTION: Configures these math functions to accept and return
             angles in radians:  ACOS, ANGLE, ASIN, ASN, ATN, ATAN, COS, COT,
             CSC, SEC, SIN and TAN.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ARITHMETIC
DESCRIPTION: OPTION ARITHMETIC by itself is a syntax error.Use
             OPTION ARITHMETIC DECIMAL, OPTION ARITHMETIC FIXED, or OPTION
             ARITHMETIC NATIVE instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ARITHMETIC DECIMAL
DESCRIPTION: Currently has no effect.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ARITHMETIC FIXED
DESCRIPTION: Currently has no effect.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ARITHMETIC NATIVE
DESCRIPTION: Currently has no effect.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION BASE X
DESCRIPTION: Sets the lowest array subscript to X.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION BUGS
DESCRIPTION: OPTION BUGS by itself is a syntax error.  Use OPTION
             BUGS OFF or OPTION BUGS ON instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION BUGS OFF
DESCRIPTION: Disables bugs commonly found in BASIC-80 derivatives
             and clones.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION BUGS ON
DESCRIPTION: Enables bugs commonly found in BASIC-80 derivatives
             and clones.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION COMMENT char
DESCRIPTION: Sets the comment character.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION COMPARE
DESCRIPTION: OPTION COMPARE by itself is a syntax error.  Use
             OPTION COMPARE BINARY, OPTION COMPARE DATABASE, or OPTION COMPARE
             TEXT instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION COMPARE BINARY
DESCRIPTION: Causes string comparisons to be case-sensitive.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION COMPARE DATABASE
DESCRIPTION: Causes string comparisons to be case-insensitive.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION COMPARE TEXT
DESCRIPTION: Causes string comparisons to be case-insensitive.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION COVERAGE
DESCRIPTION: OPTION COVERAGE by itself is a syntax error.Use
             OPTION COVERAGE OFF or OPTION COVERAGE ON instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION COVERAGE OFF
DESCRIPTION: Disables BASIC code coverage recording, displayed
             using the LIST command.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION COVERAGE ON
DESCRIPTION: Enables BASIC code coverage recording, displayed
             using the LIST command.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION DATE format
DESCRIPTION: Sets the date format string used by C strftime()
             for DATE$.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION DISABLE
DESCRIPTION: OPTION DISABLE by itself is a syntax error.  Use
             OPTION DISABLE COMMAND, OPTION DISABLE FUNCTION, or OPTION DISABLE
             OPERATOR instead
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION DISABLE COMMAND name
DESCRIPTION: Disables the specified BASIC command.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION DISABLE FUNCTION name
DESCRIPTION: Disables the specified BASIC function.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION DISABLE OPERATOR name
DESCRIPTION: Disables the specified BASIC operator.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ENABLE
DESCRIPTION: OPTION ENABLE by itself is a syntax error.  Use
             OPTION ENABLE COMMAND, OPTION ENABLE FUNCTION, or OPTION ENABLE
             OPERATOR instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ENABLE COMMAND name
DESCRIPTION: Enables the specified BASIC command.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ENABLE FUNCTION name
DESCRIPTION: Enables the specified BASIC function.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ENABLE OPERATOR name
DESCRIPTION: Enables the specified BASIC operator.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ERROR
DESCRIPTION: OPTION ERROR by itself is a syntax error.  Use OPTION
             ERROR GOSUB or OPTION ERROR GOTO instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ERROR GOSUB
DESCRIPTION: When an error occurs, GOSUB to the error handler.
             The error handler exits with RETURN.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ERROR GOTO
DESCRIPTION: When an error occurs, GOTO to the error handler.
             The error handler exits with RESUME.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION EXPLICIT
DESCRIPTION: All variables must be declared using DIM.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION IMAGE char
DESCRIPTION: Sets the shortcut IMAGE character.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION IMPLICIT
DESCRIPTION: Variables need not be declared using DIM, provided
             arrays have no more that 10 elements.  This is the opposite of
             OPTION EXPLICIT, and is the default for all versions of BASIC.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION INDENT number
DESCRIPTION: Sets indention level for LIST.  Zero means no indention.
             Default is 2.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION LABELS
DESCRIPTION: OPTION LABELS by itself is a syntax error.  Use
             OPTION LABELS OFF or OPTION LABELS ON instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION LABELS OFF
DESCRIPTION: Disables text labels.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION LABELS ON
DESCRIPTION: Enables text labels.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION PRINT char
DESCRIPTION: Sets the shortcut PRINT character.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ROUND
DESCRIPTION: OPTION ROUND by itself is a syntax error.  Use OPTION
             ROUND BANK, OPTION ROUND MATH, or OPTION ROUND TRUNCATE instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ROUND BANK
DESCRIPTION: Round using the Banker's rule.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ROUND MATH
DESCRIPTION: Round using mathematical rules.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION ROUND TRUNCATE
DESCRIPTION: Round using truncation.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION SLEEP number
DESCRIPTION: Sets multiplier for SLEEP and WAIT.  Zero means
             no waiting.  Default is 1.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION STATEMENT char
DESCRIPTION: Sets the statement seperator character.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION STDERR filename$
DESCRIPTION: Sets the file used for STDERR, which is used by
             LPRINT commands.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION STDIN filename$
DESCRIPTION: Sets the file used for STDIN, which is used by INPUT
             commands.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION STDOUT filename$
DESCRIPTION: Sets the file used for STDOUT, which is used by
             PRINT commands.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION STRICT
DESCRIPTION: OPTION STRICT by itself is a syntax error.  Use
             OPTION STRICT OFF or OPTION STRICT ON instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION STRICT OFF
DESCRIPTION: Disables checking for implicit array creation without
             using the DIM command.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION STRICT ON
DESCRIPTION: Enables checking for implicit array creation without
             using the DIM command.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION TERMINAL
DESCRIPTION: OPTION TERMINAL by itself is a syntax error.  Use
             OPTION TERMINAL ADM, OPTION TERMINAL ANSI, or OPTION TERMINAL
             NONE instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION TERMINAL ADM
DESCRIPTION: Enables ADM-3A terminal control codes for CLS, COLOR,
             and LOCATE.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION TERMINAL ANSI
DESCRIPTION: Enables ANSI terminal control codes for CLS, COLOR,
             and LOCATE.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION TERMINAL NONE
DESCRIPTION: Disables terminal control codes for CLS, COLOR,
             and LOCATE.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION TIME format
DESCRIPTION: Sets the time format string used by C strftime()
             for TIME$.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION TRACE
DESCRIPTION: OPTION TRACE by itself is a syntax error.  Use OPTION
             TRACE OFF or OPTION TRACE ON instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION TRACE OFF
DESCRIPTION: Disables displaying a stack trace when an ERROR
             occurs.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION TRACE ON
DESCRIPTION: Enables displaying a stack trace when an ERROR occurs.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION USING string$
DESCRIPTION: Specifies the magic characters for the PRINT USING
             command.  A common value for string$ is '#,.+-^$*_!&%'.  Please
             examine the source code for bwb_OPTION_USING for details regarding
             the meaning of each character position.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: OPTION VERSION [version]
DESCRIPTION: Selects a combination of OPTION settings and enables
             certain commands and functions.  If no version is specified,
             displays a list of the available versions.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: PAUSE [comment]
DESCRIPTION: Pauses processing until the ENTER key is presseed.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: POP
DESCRIPTION: Pops one GOSUB from the return stack.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: PRINT [# device-number,][USING format$;] expressions ...
DESCRIPTION: Sends output to a file.  #0 is the console(stdout).
             #-1 goes to the printer(stderr).
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: PUT filename$ , value [, ...]
DESCRIPTION: Puts one (or more) values into a file.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: QUIT
DESCRIPTION: Exits to the operating system.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: READ variable [, ...]
DESCRIPTION: Reads values from DATA statements.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: RECALL ArrayName
DESCRIPTION: Loads a numeric array from a file saved using STORE.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: REM ...
DESCRIPTION: Remark.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: RENAME [file-name$]
DESCRIPTION: Changes the file name which will be used by SAVE.
             Does not save the file.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: RENUM
DESCRIPTION: Implementation defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: RENUMBER
DESCRIPTION: Implementation defined.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: RESET filename$ [, ...]
DESCRIPTION: Positions an input or output file to the bcginning.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: RESTORE [line]
DESCRIPTION: Resets the line used for the next READ statement.
             'line' may be either a number or a label.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: RESUME [ 0 | line | NEXT ]
DESCRIPTION: Used in an error handler to specify the next line
             to execute.  RESUME and RESUME 0 branch to ERL.  RESUME NEXT
             branches to the line after ERL.  RESUME line branches to the
             specified line.  'line' may be either a number or a label.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: RETURN
DESCRIPTION: Concludes a subroutine called by GOSUB.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: RSET string-variable$ = expression
DESCRIPTION: Right-aligns the value of expression into string-variable$.
             If the length of the value is too short, then it is padded on
             the left with spaces.  If the length of the value is too long,
             then it is truncated on the right.  This is only for use with
             variables assigned to a random access buffer with FIELD command.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: RUN [line | file-name$]
DESCRIPTION: RUN executes the program in memory from the start.
             RUN line exexecutes the program in memory beginning at 'line'.
             RUN file-name$ loads a new BAASIC program and executes the program
             from the start.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: SAVE [file-name$]
DESCRIPTION: Saves the current program into the file file-name$
             in ASCII format.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: SCRATCH # X
DESCRIPTION: Sets the file mode to writing.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: SELECT
DESCRIPTION: SELECT by itself is a syntax error.  Use SELECT
             CASE instead.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: SELECT CASE expression
DESCRIPTION: Introduces a multi-line conditional selection statement.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: STEP
DESCRIPTION: STEP by itself is a syntax error.  Use FOR ... STEP
             instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: STOP
DESCRIPTION: Interrupts program execution and displays the line
             number of the STOP command.  For use when debugging BASIC programs.
             Whether STOP issues a SIGINT signal is implementation defined.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: STORE ArrayName
DESCRIPTION: Saves a numeric array into a file for later loading
             by RECALL.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: SUB name [ ( parameter [,...] ) ]
DESCRIPTION: Top line of a multi-line SUB definition.  The variable
             names specified are local to the SUB definition, and are initialized
             BYVAL when the subroutine is invoked by another routine.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: SUBEND
DESCRIPTION: Specifies the last line of a multi-line SUB definition.
             Same as END SUB.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: SWAP variable, variable
DESCRIPTION: Swaps the values of two variables. Both variables
             must be of the same type.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: SYSTEM
DESCRIPTION: Exits to the operating system.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: TEXT letter[-letter] [, ...]
DESCRIPTION: Declares variables with single-letter names as string
             variables.  Same as DEFSTR.  TODO: enforce the range of [MINLEN,MAXLEN].
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: THEN line1
DESCRIPTION: THEN by itself is a syntax error.  Use IF ... THEN
             line1 instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: TIMER
DESCRIPTION: TIMER by itself is a syntax error.  Use TIMER OFF,
             TIMER ON, or TIMER STOP instead.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: TIMER OFF
DESCRIPTION: TIMER OFF terminates the timer interrupt.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: TIMER ON
DESCRIPTION: TIMER ON enables the timer interrupt.  When the
             specified seconds have elapsed, TIMER STOP is internaly executed
             before the interrupt is taken.  TIMER ON should be executed just
             before the RETURN command if you want the interrupt to occur
             again.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: TIMER STOP
DESCRIPTION: TIMER STOP disables the interrupt, but the count
             continues.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: TLOAD [file-name$]
DESCRIPTION: Loads an ASCII BASIC program into memory.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: TO
DESCRIPTION: TO by itself is a syntax error.  Use FOR ... TO
             instead.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: TRACE ON | OFF
DESCRIPTION: TRACE enables tracing.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: TRACE OFF
DESCRIPTION: Disables tracing.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: TRACE ON
DESCRIPTION: TRACE ON enables tracing.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: TSAVE [file-name$]
DESCRIPTION: Saves the current program into the file file-name$
             in ASCII format.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: UEND
DESCRIPTION: Bottom of a UNTIL - UEND structure.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: UNTIL expression
DESCRIPTION: Top of a UNTIL - UEND structure.  If the expression
             is zero, then the loop is terminated.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: USE parameter$
DESCRIPTION: Receives the value from the calling CHAINing program.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: USER LBL
DESCRIPTION: An internal command that allows the BASIC program
             to find a user label.  You do not directly call this command.
             If your program has a line with a label, then USER LBL is used
             to mark the line.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: VARS
DESCRIPTION: Prints a list of all global variables.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: WEND
DESCRIPTION: Bottom of a WHILE - WEND structure.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: WHILE
DESCRIPTION: Top of a WHILE - WEND structure.  If the expression
             is non-zero, then the loop is terminated.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: WRITE [# device-number,] element [, .... ]
DESCRIPTION: Outputs variables to the screen or to a file.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
============================================================
                    FUNCTIONS                               
============================================================


------------------------------------------------------------
     SYNTAX: N  = ABS( X )
  PARAMETER: X  is a number
DESCRIPTION: The absolute value of X.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = ACOS( X )
  PARAMETER: X  is a number
DESCRIPTION: The arccosine of X in radians, where 0 <= ACOS(X)
             <= PI.  X shall be in the range -1 <= X <= 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ACS( X )
  PARAMETER: X  is a number
DESCRIPTION: The arccosine of X in radians, where 0 <= ACS(X)
             <= PI.  X shall be in the range -1 <= X <= 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ACSD( X )
  PARAMETER: X  is a number
DESCRIPTION: The arccosine of X in degrees, where 0 <= ACSD(X)
             <= 180.  X shall be in the range -1 <= X <= 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ACSG( X )
  PARAMETER: X  is a number
DESCRIPTION: The arccosine of X in gradians, where 0 <= ACS(X)
             <= 200.  X shall be in the range -1 <= X <= 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ANGLE( X, Y )
  PARAMETER: X  is a number
  PARAMETER: Y  is a number
DESCRIPTION: The angle in radians between the positive x-axis
             and the vector joining the origin to the point with coordinates
             (X, Y), where -PI < ANGLE(X,Y) <= PI.  X and Y must not both
             be 0.  Note that the counterclockwise is positive, e.g., ANGLE(1,1)
             = 45 degrees.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ARCSIN( X )
  PARAMETER: X  is a number
DESCRIPTION: The arcsine of X in radians, where -PI/2 <= ARCSIN(X)
             <= PI/2; X shall be in the range -1 <= X <= 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ARCTAN( X )
  PARAMETER: X  is a number
DESCRIPTION: The arctangent of X in radians, i.e. the angle whose
             tangent is X, where -PI/2 < ARCTAN(X) < PI/2.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ARGC
DESCRIPTION: The number of parameters passed to a FUNCTION or
             SUB.  If not in a FUNCTION or SUB, returns -1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = ARGT$( X )
  PARAMETER: X  is a number, [MININT,MAXINT]
DESCRIPTION: The type of the X'th parameter to a FUNCTION or
             SUB.  If the X'th parameter is a string, then return value is
             '$'.  If the X'th parameter is a number, then return value is
             not '$'.  X in [1,ARGC].
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ARGV( X )
  PARAMETER: X  is a number, [MININT,MAXINT]
DESCRIPTION: The value of the X'th parameter to a FUNCTION or
             SUB.  X in [1,ARGC] and ARGT$( X ) <> '$'.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = ARGV$( X )
  PARAMETER: X  is a number, [MININT,MAXINT]
DESCRIPTION: The value of the X'th parameter to a FUNCTION or
             SUB.  X in [1,ARGC] and ARGT$( X ) = '$'.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ASC( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: The numeric code for the first letter in A$.  For
             example, ASC("ABC") returns 65 on ASCII systems.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = ASC( A$, X )
  PARAMETER: A$ is a string, LEN >= 1
  PARAMETER: X  is a number, [1,MAXLEN]
DESCRIPTION: The numeric code of the X'th character in A$.  Same
             as ASC(MID$(A$,X)).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ASCII( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: The numeric code for the first letter in A$.  For
             example, ASCII("ABC") returns 65 on ASCII systems.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ASIN( X )
  PARAMETER: X  is a number
DESCRIPTION: The arcsine of X in radians, where -PI/2 <= ASIN(X)
             <= PI/2; X shall be in the range -1 <= X <= 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ASN( X )
  PARAMETER: X  is a number
DESCRIPTION: The arcsine of X in radians, where -PI/2 <= ASN(X)
             <= PI/2; X shall be in the range -1 <= X <= 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ASND( X )
  PARAMETER: X  is a number
DESCRIPTION: The arcsine of X in degrees, where -90 <= ASN(X)
             <= 90; X shall be in the range -1 <= X <= 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ASNG( X )
  PARAMETER: X  is a number
DESCRIPTION: The arcsine of X in radians, where -100 <= ASNG(X)
             <= 100; X shall be in the range -1 <= X <= 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ATAN( X )
  PARAMETER: X  is a number
DESCRIPTION: The arctangent of X in radians, i.e. the angle whose
             tangent is X, where -PI/2 < ATAN(X) < PI/2.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ATN( X )
  PARAMETER: X  is a number
DESCRIPTION: The arctangent of X in radians, i.e. the angle whose
             tangent is X, where -PI/2 < ATN(X) < PI/2.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = ATND( X )
  PARAMETER: X  is a number
DESCRIPTION: The arctangent of X in degrees, i.e. the angle whose
             tangent is X, where -90 < ATND(X) < 90.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ATNG( X )
  PARAMETER: X  is a number
DESCRIPTION: The arctangent of X in gradians, i.e. the angle
             whose tangent is X, where -100 < ATND(X) < 100.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = BASE
DESCRIPTION: The current OPTION BASE setting.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CATALOG
DESCRIPTION: Displays all the file names.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CATALOG( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: Displays all the file names matching A$.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CCUR( X )
  PARAMETER: X  is a number, [MINCUR,MAXCUR]
DESCRIPTION: The currency (64-bit) integer value of X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CDBL( X )
  PARAMETER: X  is a number, [MINDBL,MAXDBL]
DESCRIPTION: The double-precision value of X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = CEIL( X )
  PARAMETER: X  is a number
DESCRIPTION: The smallest integer not less than X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = CHAR( X, Y )
  PARAMETER: X  is a number, [0,255]
  PARAMETER: Y  is a number, [0,MAXLEN]
DESCRIPTION: The string Y bytes long consisting of CHR$(X). 
             Same as STRING$(Y,X).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = CHAR$( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: The one-character string with the character corresponding
             to the numeric code X.  On ASCII systems, CHAR$(65) returns 'A'.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CHDIR( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: Changes to the directory named to A$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = CHR( X )
  PARAMETER: X  is a number
DESCRIPTION: The one-character string with the character corresponding
             to the numeric code X.  On ASCII systems, CHR(65) returns 'A'.For
             the IBM System/360 and System/370, this function returns the
             output of PRINT X, so A$ = CHR(X) is the opposite of X = NUM(A$).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = CHR$( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: The one-character string with the character corresponding
             to the numeric code X.  On ASCII systems, CHR$(65) returns 'A'.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = CINT( X )
  PARAMETER: X  is a number, [MININT,MAXINT]
DESCRIPTION: The short (16-bit) integer value of X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = CLG( X )
  PARAMETER: X  is a number, >  0
DESCRIPTION: The common logarithm of X; X shall be greater than
             zero.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = CLK( X )
  PARAMETER: X  is a number
DESCRIPTION: The time of day in 24-hour notation according to
             ISO 3307.  For example, the value of CLK at 11:15 AM is '11:15:00'.
             If there is no clock available, then the value of CLK shall
             be '99:99:99'.  The value of TIME$ at midnight is '00:00:00'.
             The value of parameter X is ignored.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CLK( X )
  PARAMETER: X  is a number
DESCRIPTION: The time elapsed since the previous midnight, expressed
             in hours; e.g., the value of CLK at 3:15 PM is 15.25.  If there
             is no clock available, then the value of CLK shall be -1.  The
             value of CLK at midnight shall be zero (not 24).  The value of
             X is ignored.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = CLK$
DESCRIPTION: The time of day in 24-hour notation according to
             ISO 3307.  For example, the value of TIME$ at 11:15 AM is '11:15:00'.
             If there is no clock available, then the value of TIME$ shall
             be '99:99:99'.  The value of TIME$ at midnight is '00:00:00'.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CLNG( X )
  PARAMETER: X  is a number, [MINLNG,MAXLNG]
DESCRIPTION: The long (32-bit) integer value of X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = CLOG( X )
  PARAMETER: X  is a number, >  0
DESCRIPTION: The common logarithm of X; X shall be greater than
             zero.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CLOSE
DESCRIPTION: Close all open files.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = CLOSE( X )
  PARAMETER: X  is a number, [1,MAXDEV]
DESCRIPTION: Close file number X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = CLS
DESCRIPTION: Clears the screen. Cursor is positioned at row 1,
             column 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = CODE( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: The numeric code for the first letter in A$.  For
             example, CODE("ABC") returns 65 on ASCII systems.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = COLOR( X, Y )
  PARAMETER: X  is a number, [0,255]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: Sets the foreground text color to X, and the background
             text color to Y.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = COMMAND$( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: The command line parameters.  COMMAND$(0) is the
             BASIC program name.  COMMAND$(1) is the first parameter after
             the BASIC program name, and so on.  Support for parameters varies
             by operating system, compiler, and so on.  X in [0..9]  
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = COS( X )
  PARAMETER: X  is a number
DESCRIPTION: The cosine of X, where X is in radians.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = COSD( X )
  PARAMETER: X  is a number
DESCRIPTION: The cosine of X, where X is in degrees.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = COSG( X )
  PARAMETER: X  is a number
DESCRIPTION: The cosine of X, where X is in gradians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = COSH( X )
  PARAMETER: X  is a number
DESCRIPTION: The hyperbolic cosine of X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = COT( X )
  PARAMETER: X  is a number
DESCRIPTION: The cotangent of X, where X is in radians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = COUNT
DESCRIPTION: The current cursor position in the line.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CSC( X )
  PARAMETER: X  is a number
DESCRIPTION: The cosecant of X, where X is in radians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CSH( X )
  PARAMETER: X  is a number
DESCRIPTION: The hyperbolic cosine of X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CSNG( X )
  PARAMETER: X  is a number, [MINFLT,MAXFLT]
DESCRIPTION: The single-precision value of X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = CUR( X, Y )
  PARAMETER: X  is a number, [0,255]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: Locates the cursor to row X, column Y.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CVC( A$ )
  PARAMETER: A$ is a string, LEN >= sizeof(CUR)
DESCRIPTION: The currency (64-bit) integer value in A$, which
             was created by MKC$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = CVD( A$ )
  PARAMETER: A$ is a string, LEN >= sizeof(DBL)
DESCRIPTION: The double-precision value in A$, which was created
             by MKD$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = CVI( A$ )
  PARAMETER: A$ is a string, LEN >= sizeof(INT)
DESCRIPTION: The short (16-bit) integer value in A$, which was
             created by MKI$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = CVL( A$ )
  PARAMETER: A$ is a string, LEN >= sizeof(LNG)
DESCRIPTION: The long (32-bit) integer value in A$, which was
             created by MKL$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = CVS( A$ )
  PARAMETER: A$ is a string, LEN >= sizeof(FLT)
DESCRIPTION: The single-precision value in A$, which was created
             by MKS$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = DAT$
DESCRIPTION: Mark-II: The current date based on the computer's
             internal clock as a string in the form 'MM/DD/YY'.  If there
             is no calendar available, then the value of DAT$ shall be '00/00/00'.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = DATE
DESCRIPTION: The current date in decimal form YYYDDD, where YYY
             are the number of years since 1900 and DDD is the ordinal number
             of the current day of the year; e.g., the value of DATE on May
             9, 1977 was 77129.  If there is no calendar available, then the
             value of DATE shall be -1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = DATE$
DESCRIPTION: BASIC-80: The current date based on the computer's
             internal clock as a string in the form 'MM-DD-YYYY'.ECMA-116:
             The date in the string representation 'YYYYMMDD' according to
             ISO 2014.  For example, the value of DATE$ on May 9, 1977 was
             '19770509'.  If there is no calendar available, then the value
             of DATE$ shall be '00000000'.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = DATE$( X )
  PARAMETER: X  is a number
DESCRIPTION: BASIC-80: The current date based on the computer's
             internal clock as a string in the form 'MM-DD-YYYY'.ECMA-116:
             The date in the string representation 'YYYYMMDD' according to
             ISO 2014.  For example, the value of DATE$ on May 9, 1977 was
             '19770509'.  If there is no calendar available, then the value
             of DATE$ shall be '00000000'.  The value of parameter 'X' is
             ignored.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = DEF FN
DESCRIPTION: User Function.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = DEG
DESCRIPTION: Configures the math functions to accept and return
             angles in degrees.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = DEG( X )
  PARAMETER: X  is a number
DESCRIPTION: The number of degrees in X radians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = DEGREE
DESCRIPTION: Configures the math functions to accept and return
             angles in degrees.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = DEGREE( X )
  PARAMETER: X  is a number
DESCRIPTION: The number of degrees in X radians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = DET
DESCRIPTION: The determinant of the last MAT INV.  Zero means
             error.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = DIM( ... )
DESCRIPTION: DIM( arrayname ).  The total number of dimensions
             of the array.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ENVIRON( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: Sends the environment variable expression contained
             in A$ to the host operating system.  A$ must contain the  '='
             character.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = ENVIRON$( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: The value of the environment variable named A$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = EOF( X )
  PARAMETER: X  is a number, [1,MAXDEV]
DESCRIPTION: If device number X is at the end-of-file, then -1,
             otherwise 0.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = EPS( X )
  PARAMETER: X  is a number
DESCRIPTION: The maximum of (X-X1,X2-X, sigma) where X1 and X2
             are the predecessor and successor of X and signma is the smallest
             positive value representable.  If X has no predecessor the X1=X
             and if X has no successor the X2=X.  Note EPS(0) is the smallest
             positive number representable by the implementation, and is therefor
             implementation-defined.  Note also that EPS may produce different
             results for different arithmetic options (see OPTION ARITHMETIC).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ERL
DESCRIPTION: The line number of the most recent error.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = ERR
DESCRIPTION: The error number of the most recent error.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = ERR$
DESCRIPTION: The last error message.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = ERRL
DESCRIPTION: The line number of the most recent error.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ERRN
DESCRIPTION: The error number of the most recent error.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = ERROR( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: Simulate the error number in X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = ERROR( X, A$ )
  PARAMETER: X  is a number, [0,255]
  PARAMETER: A$ is a string, LEN >= 0
DESCRIPTION: Simulate the error number in X, with a custom message
             in A$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = ERROR$
DESCRIPTION: The last error message.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = EXAM( X )
  PARAMETER: X  is a number, [MINLNG,MAXLNG]
DESCRIPTION: The value read from hardware address X.  Not supported
             on all platforms.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = EXP( X )
  PARAMETER: X  is a number
DESCRIPTION: The exponential value of X, i.e., the value of the
             base of natural logarithms (e = 2.71828) raised to the power
             of X;  if EXP(X) is less that machine infinitesimal, then its
             value shall be replaced with zero.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = FETCH( X )
  PARAMETER: X  is a number, [MINLNG,MAXLNG]
DESCRIPTION: The value read from hardware address X.  Not supported
             on all platforms.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = FILEATTR( X, Y )
  PARAMETER: X  is a number, [1,MAXDEV]
  PARAMETER: Y  is a number, [MININT,MAXINT]
DESCRIPTION: For file X, if Y = 1 then returns open mode, otherwise
             returns zero.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = FILES
DESCRIPTION: Displays all the file names.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = FILES( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: Displays all the file names matching A$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = FILL( X, Y )
  PARAMETER: X  is a number, [MINLNG,MAXLNG]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: Sends Y to hardware address X.  Not supported on
             all platforms.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = FIX( X )
  PARAMETER: X  is a number
DESCRIPTION: The truncated integer, part of X. FIX (X) is equivalent
             to SGN(X)*INT(ABS(X)). The major difference between FIX and INT
             is that FIX does not return the next lower number for negative
             X.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = FLOAT( X )
  PARAMETER: X  is a number
DESCRIPTION: The rounded integer valuet of X.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = FLOW
DESCRIPTION: Turn tracing ON
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = FP( X )
  PARAMETER: X  is a number
DESCRIPTION: The fractional part of X, i.e. X - IP(X).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = FRAC( X )
  PARAMETER: X  is a number
DESCRIPTION: The fractional part of X, i.e. X - IP(X).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = FRE
DESCRIPTION: The number of bytes of available memory.  This function
             is provided for backward compatibility only and it always returns
             a fixed value of 32000.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = FRE( A$ )
  PARAMETER: A$ is a string, LEN >= 0
DESCRIPTION: The number of bytes of available memory.  This function
             is provided for backward compatibility only and it always returns
             a fixed value of 32000.The value of A$ is ignored.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = FRE( X )
  PARAMETER: X  is a number
DESCRIPTION: The number of bytes of available memory.  This function
             is provided for backward compatibility only and it always returns
             a fixed value of 32000.  The value of X is ignored.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = FREE
DESCRIPTION: The number of bytes of available memory.  This function
             is provided for backward compatibility only and it always returns
             a fixed value of 32000.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = FREE( A$ )
  PARAMETER: A$ is a string, LEN >= 0
DESCRIPTION: The number of bytes of available memory.  This function
             is provided for backward compatibility only and it always returns
             a fixed value of 32000.The value of A$ is ignored.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = FREE( X )
  PARAMETER: X  is a number
DESCRIPTION: The number of bytes of available memory.  This function
             is provided for backward compatibility only and it always returns
             a fixed value of 32000.  The value of X is ignored.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = FREEFILE
DESCRIPTION: The next available file number.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = GET( X )
  PARAMETER: X  is a number, [1,MAXDEV]
DESCRIPTION: For file X, gets the next available record.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = GET( X, Y )
  PARAMETER: X  is a number, [1,MAXDEV]
  PARAMETER: Y  is a number, [MININT,MAXINT]
DESCRIPTION: For file X, gets record number Y.  The first record
             number is 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = GRAD
DESCRIPTION: Configures the math functions to accept and return
             angles in gradians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = GRADIAN
DESCRIPTION: Configures the math functions to accept and return
             angles in gradians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = HCS( X )
  PARAMETER: X  is a number
DESCRIPTION: The hyperbolic cosine of X.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = HEX$( X )
  PARAMETER: X  is a number, [MININT,MAXINT]
DESCRIPTION: The the hexadecimal (base 16) representation of
             X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = HOME
DESCRIPTION: Clears the screen. Cursor is positioned at row 1,
             column 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = HSN( X )
  PARAMETER: X  is a number
DESCRIPTION: The hyperbolic sine of X.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = HTN( X )
  PARAMETER: X  is a number
DESCRIPTION: The hyperbolic tangent of X.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = INDEX( A$, B$ )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: B$ is a string, LEN >= 0
DESCRIPTION: The position at which B$ occurs in A$, beginning
             at position 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = INITIALIZE
DESCRIPTION: This function is provided for backward compatibility
             only and it always returns a fixed value of 0.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = INKEY$
DESCRIPTION: The keypress, if available. If a keypress is not
             available, then immediately returns a null string ('').  If not
             supported by the platform, then always returns an empty string,
             so use INPUT$(1) instead.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = INP( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: The value read from machine port X.  Not supported
             on all platforms.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = INPUT$( X )
  PARAMETER: X  is a number, [0,MAXLEN]
DESCRIPTION: The string of X characters, read from the terminal.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = INPUT$( X, Y )
  PARAMETER: X  is a number, [0,MAXLEN]
  PARAMETER: Y  is a number, [1,MAXDEV]
DESCRIPTION: The string of X characters, read from file Y.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = INSTR( A$, B$ )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: B$ is a string, LEN >= 0
DESCRIPTION: The position at which B$ occurs in A$, beginning
             at position 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = INSTR( X, A$, B$ )
  PARAMETER: X  is a number, [1,MAXLEN]
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: B$ is a string, LEN >= 0
DESCRIPTION: The position at which B$ occurs in A$, beginning
             at position X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = INT( X )
  PARAMETER: X  is a number
DESCRIPTION: The largest integer not greater than X; e.g. INT(1.3)
             = 1 and INT(-1.3) = 2.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = INT%( X )
  PARAMETER: X  is a number
DESCRIPTION: The rounded integer valuet of X.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = IP( X )
  PARAMETER: X  is a number
DESCRIPTION: The integer part of X, i.e., SGN(X)*INT(ABS(X)).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = KEY
DESCRIPTION: The keypress, if available. If a keypress is not
             available, then immediately returns a null string ('').  If not
             supported by the platform, then always returns an empty string,
             so use INPUT$(1) instead.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = KEY$
DESCRIPTION: The keypress, if available. If a keypress is not
             available, then immediately returns a null string ('').  If not
             supported by the platform, then always returns an empty string,
             so use INPUT$(1) instead.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = KILL( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: Removes the file named in A$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = LBOUND( ... )
DESCRIPTION: LBOUND( arrayname [, dimension] ).  The lower bound
             of the array.  The dimension defaults to 1.  dimension in [1,DIM(arrayname)]
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = LCASE$( A$ )
  PARAMETER: A$ is a string, LEN >= 0
DESCRIPTION: The string of characters from the value associatedwith
             A$ by replacing each upper-case-letter in the string by its lower-case
             version.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = LEFT( A$, X )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: X  is a number, [0,MAXLEN]
DESCRIPTION: The X left-most characters of A$, beginning from
             postion 1.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = LEFT$( A$, X )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: X  is a number, [0,MAXLEN]
DESCRIPTION: The X left-most characters of A$, beginning from
             postion 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = LEN( A$ )
  PARAMETER: A$ is a string, LEN >= 0
DESCRIPTION: The length of A$.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = LGT( X )
  PARAMETER: X  is a number, >  0
DESCRIPTION: The common logarithm of X; X shall be greater than
             zero.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = LIN( X )
  PARAMETER: X  is a number, [0,MAXLEN]
DESCRIPTION: The string X bytes long of newline characters.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = LN( X )
  PARAMETER: X  is a number, >  0
DESCRIPTION: The natural logarithm of X; X shall be greater than
             zero.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = LOC( X )
  PARAMETER: X  is a number, [1,MAXDEV]
DESCRIPTION: The location of file X; the next record that GET
             or PUT statements will use.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = LOCATE( X, Y )
  PARAMETER: X  is a number, [0,255]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: Locates the cursor to row X, column Y.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = LOF( X )
  PARAMETER: X  is a number, [1,MAXDEV]
DESCRIPTION: The length of file X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = LOG( X )
  PARAMETER: X  is a number, >  0
DESCRIPTION: The natural logarithm of X; X shall be greater than
             zero.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = LOG10( X )
  PARAMETER: X  is a number, >  0
DESCRIPTION: The common logarithm of X; X shall be greater than
             zero.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = LOG2( X )
  PARAMETER: X  is a number, >  0
DESCRIPTION: The base 2 logarithm of X; X shall be greater than
             zero.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = LOGE( X )
  PARAMETER: X  is a number, >  0
DESCRIPTION: The natural logarithm of X; X shall be greater than
             zero.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = LPOS
DESCRIPTION: The current cursor position in the line for the
             printer.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = LTRIM$( A$ )
  PARAMETER: A$ is a string, LEN >= 0
DESCRIPTION: The string of characters resulting from the value
             associated with A$ by deleting all leading space characters.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = LTW( X )
  PARAMETER: X  is a number, >  0
DESCRIPTION: The base 2 logarithm of X; X shall be greater than
             zero.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = LWIDTH( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: For printer, sets the line width to X. Zero means
             no wrapping will occur.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = MATCH( A$, B$, X )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: B$ is a string, LEN >= 0
  PARAMETER: X  is a number, [1,MAXLEN]
DESCRIPTION: The character position, within the value assocated
             with A$, of the first character of the first occurence of the
             value associated with B$, starting at the Xth character of A$.
             If there is not such occurence, then the value returned is zero.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MAX( X, Y )
  PARAMETER: X  is a number
  PARAMETER: Y  is a number
DESCRIPTION: The larger of the parameters.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = MAX( A$, B$ )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: B$ is a string, LEN >= 0
DESCRIPTION: The larger of the parameters.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MAXBYT
DESCRIPTION: The largest finite positive number representable
             as a BYTE; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MAXCUR
DESCRIPTION: The largest finite positive number representable
             as a CURRENCY; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MAXDBL
DESCRIPTION: The largest finite positive number representable
             as a DOUBLE; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MAXDEV
DESCRIPTION: The largest finite positive number useable as a
             FILE NUMBER; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MAXINT
DESCRIPTION: The largest finite positive number representable
             as an INTEGER; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MAXLEN( A$ )
  PARAMETER: A$ is a string, LEN >= 0
DESCRIPTION: The maximum length associated with the simple-string-variable
             A$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MAXLNG
DESCRIPTION: The largest finite positive number representable
             as a LONG; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MAXLVL
DESCRIPTION: The maximum stack level; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MAXNUM
DESCRIPTION: The largest finite positive number representable
             and manipulable by the implementation; implementation-defined.
             MAXNUM may represent diffent number for different arithmetic
             options (see OPTION ARITHMETIC).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MAXSNG
DESCRIPTION: The largest finite positive number representable
             as a SINGLE; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MEM
DESCRIPTION: The number of bytes of available memory.  This function
             is provided for backward compatibility only and it always returns
             a fixed value of 32000.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = MID( A$, X )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: X  is a number, [1,MAXLEN]
DESCRIPTION: The characters of A$, starting from postion X.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = MID( A$, X, Y )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: X  is a number, [1,MAXLEN]
  PARAMETER: Y  is a number, [0,MAXLEN]
DESCRIPTION: The Y characters of A$, starting from postion X.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = MID$( A$, X )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: X  is a number, [1,MAXLEN]
DESCRIPTION: The characters of A$, starting from postion X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = MID$( A$, X, Y )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: X  is a number, [1,MAXLEN]
  PARAMETER: Y  is a number, [0,MAXLEN]
DESCRIPTION: The Y characters of A$, starting from postion X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = MIN( X, Y )
  PARAMETER: X  is a number
  PARAMETER: Y  is a number
DESCRIPTION: The smaller of the parameters.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = MIN( A$, B$ )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: B$ is a string, LEN >= 0
DESCRIPTION: The smaller of the parameters.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MINBYT
DESCRIPTION: The largest finite negative number representable
             as a BYTE; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MINCUR
DESCRIPTION: The largest finite negative number representable
             as a CURRENCY; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MINDBL
DESCRIPTION: The largest finite negative number representable
             as a DOUBLE; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MINDEV
DESCRIPTION: The largest finite negative number useable as a
             FILE NUMBER; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MININT
DESCRIPTION: The largest finite negative number representable
             as an INTEGER; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MINLNG
DESCRIPTION: The largest finite negative number representable
             as a LONG; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MINNUM
DESCRIPTION: The largest finite negative number representable
             and manipulable by the implementation; implementation-defined.
             MINNUM may represent diffent number for different arithmetic
             options (see OPTION ARITHMETIC).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = MINSNG
DESCRIPTION: The largest finite negative number representable
             as a SINGLE; implementation-defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = MKC$( X )
  PARAMETER: X  is a number, [MINCUR,MAXCUR]
DESCRIPTION: The internal representation of the currency (64-bit)
             integer X as a string.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = MKD$( X )
  PARAMETER: X  is a number, [MINDBL,MAXDBL]
DESCRIPTION: The internal representation of X as a string.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = MKDIR( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: Makes the directory named in A$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = MKI$( X )
  PARAMETER: X  is a number, [MININT,MAXINT]
DESCRIPTION: The internal representation of the short (16-bit)
             integer X as a string.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = MKL$( X )
  PARAMETER: X  is a number, [MINLNG,MAXLNG]
DESCRIPTION: The internal representation of the long (32-bit)
             integer X as a string.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = MKS$( X )
  PARAMETER: X  is a number, [MINFLT,MAXFLT]
DESCRIPTION: The internal representation of X as a string.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = MOD( X, Y )
  PARAMETER: X  is a number
  PARAMETER: Y  is a number, <> 0
DESCRIPTION: X modulo Y, i.e., X-Y*INT(X/Y).  Y shall not equal
             zero.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = NAME( A$, B$ )
  PARAMETER: A$ is a string, LEN >= 1
  PARAMETER: B$ is a string, LEN >= 1
DESCRIPTION: Rename the file named A$ into B$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = NOFLOW
DESCRIPTION: Turn tracing OFF
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = NOTRACE
DESCRIPTION: Turn tracing OFF
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = NULL( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: Appends X null characters after each line printed
             by LPRINT or LLIST.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = NUM
DESCRIPTION: The number of values processed by the last MAT INPUT.
             Zero means error.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = NUM( A$ )
  PARAMETER: A$ is a string, LEN >= 0
DESCRIPTION: The value of the numeric-constant associated with
             A$, if the string associated with A$ is a numeric-constant. 
             Leading and trailing spaces in the string are ignored.  If the
             evaluation of the numeric-constant would result in a value which
             causes an underflow, then the value returned shall be zero. 
             For example, NUM(' 123.5 ' ) = 123.5, NUM('2.E-99') could be
             zero, and NUM('MCMXVII') causes an exception.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = NUM$( X )
  PARAMETER: X  is a number
DESCRIPTION: The string generated by the print-statement as the
             numeric-representation of the value associated with X.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = OCT$( X )
  PARAMETER: X  is a number, [MININT,MAXINT]
DESCRIPTION: The the octal (base 8) representation of X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = OPEN( A$, X, B$ )
  PARAMETER: A$ is a string, LEN >= 1
  PARAMETER: X  is a number, [1,MAXDEV]
  PARAMETER: B$ is a string, LEN >= 1
DESCRIPTION: Open file number X.  A$ is the mode: I, O, A, R.
             B$ is the file name.  Default the record length.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = OPEN( A$, X, B$, Y )
  PARAMETER: A$ is a string, LEN >= 1
  PARAMETER: X  is a number, [1,MAXDEV]
  PARAMETER: B$ is a string, LEN >= 1
  PARAMETER: Y  is a number, [MININT,MAXINT]
DESCRIPTION: Open file number X.  A$ is the mode: I, O, A, R.
             B$ is the file name.  Y is the record length.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = ORD( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: The ordinal position of the character named by the
             string associated with A$ in the collating sequence of ASCII
             character set, where the first member of the character set is
             in position zero.  The acceptable values for the standard character
             set are shown in Table 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = OUT( X, Y )
  PARAMETER: X  is a number, [MININT,MAXINT]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: Sends Y to hardware port X.  Not supported on all
             platforms.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = PAUSE( X )
  PARAMETER: X  is a number
DESCRIPTION: The program pauses for X times the value of OPTION
             SLEEP seconds.  If the result is zero, negative, or more than
             INT_MAX then PAUSE does nothing.  The resolution is implementation
             defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = PDL( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: The value read from machine port X.  Not supported
             on all platforms.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = PEEK( X )
  PARAMETER: X  is a number, [MINLNG,MAXLNG]
DESCRIPTION: The value read from hardware address X.  Not supported
             on all platforms.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = PI
DESCRIPTION: The constant 3.14159 which is the ratio of the circumference
             of a circle to its diameter.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = PI( X )
  PARAMETER: X  is a number
DESCRIPTION: The constant 3.14159 which is the ratio of the circumference
             of a circle to its diameter, times X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = PIN( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: The value read from machine port X.  Not supported
             on all platforms.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = POKE( X, Y )
  PARAMETER: X  is a number, [MINLNG,MAXLNG]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: Sends Y to hardware address X.  Not supported on
             all platforms.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = POS
DESCRIPTION: The current cursor position in the line.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = POS( X )
  PARAMETER: X  is a number, [1,MAXDEV]
DESCRIPTION: The current cursor position in the line for file
             X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = POS( A$, B$ )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: B$ is a string, LEN >= 0
DESCRIPTION: The character position, within the value assocated
             with A$, of the first character of the first occurence of the
             value associated with B$, starting at the first character of
             A$.  If there is not such occurence, then the value returned
             is zero.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = POS( A$, B$, X )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: B$ is a string, LEN >= 0
  PARAMETER: X  is a number, [1,MAXLEN]
DESCRIPTION: The character position, within the value assocated
             with A$, of the first character of the first occurence of the
             value associated with B$, starting at the Xth character of A$.
             If there is not such occurence, then the value returned is zero.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = PUT( X )
  PARAMETER: X  is a number, [1,MAXDEV]
DESCRIPTION: For file X, puts the next available record.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = PUT( X, Y )
  PARAMETER: X  is a number, [1,MAXDEV]
  PARAMETER: Y  is a number, [MININT,MAXINT]
DESCRIPTION: For file X, puts record number Y.  The first record
             number is 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = RAD
DESCRIPTION: Configures the math functions to accept and return
             angles in radians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = RAD( X )
  PARAMETER: X  is a number
DESCRIPTION: The number of radians in X degrees.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = RADIAN
DESCRIPTION: Configures the math functions to accept and return
             angles in radians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = RAN
DESCRIPTION: Seeds the pseudo-random number generator with TIME.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = RAN( X )
  PARAMETER: X  is a number
DESCRIPTION: Seeds the pseudo-random number generator with X.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = RANDOM
DESCRIPTION: Seeds the pseudo-random number generator with TIME.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = RANDOM( X )
  PARAMETER: X  is a number
DESCRIPTION: Seeds the pseudo-random number generator with X.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = RANDOMIZE
DESCRIPTION: Seeds the pseudo-random number generator with TIME.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = RANDOMIZE( X )
  PARAMETER: X  is a number
DESCRIPTION: Seeds the pseudo-random number generator with X.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = REMAINDER( X, Y )
  PARAMETER: X  is a number
  PARAMETER: Y  is a number, <> 0
DESCRIPTION: The remainder function, i.e., X-Y*IP(X/Y).  Y shall
             not equal zero.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = RENAME( A$, B$ )
  PARAMETER: A$ is a string, LEN >= 1
  PARAMETER: B$ is a string, LEN >= 1
DESCRIPTION: Rename file A$ to B$.  If successful, the returns
             -1 else returns 0.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = REPEAT$( X, A$ )
  PARAMETER: X  is a number, [0,MAXLEN]
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: The string consisting of X copies of LEFT$(A$,1);
             X > 0.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = REPEAT$( X, Y )
  PARAMETER: X  is a number, [0,MAXLEN]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: The string consisting of X copies of CHR$(Y); X
             > 0.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = RESET
DESCRIPTION: Close all open files.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = RIGHT( A$, X )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: X  is a number, [0,MAXLEN]
DESCRIPTION: The right-most X characters of A$.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = RIGHT$( A$, X )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: X  is a number, [0,MAXLEN]
DESCRIPTION: The right-most X characters of A$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = RMDIR( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: Removes the directory named in A$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = RND
DESCRIPTION: The next pseudo-random number in an implementation-defined
             sequence of pseudo-random numbers uniformly distributed in the
             range 0 <= RND < 1.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = RND( X )
  PARAMETER: X  is a number
DESCRIPTION: Returns a pseudorandom number in the range [0,1].
             The value of X is ignored.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = ROUND( X, Y )
  PARAMETER: X  is a number
  PARAMETER: Y  is a number, [MININT,MAXINT]
DESCRIPTION: The value of X rounded to Y decimal digits to the
             right of the decimal point (or -Y digits to the left if Y < 0);
             i.e., INT(X*10^Y+.5)/10^Y.  Y must be in [-32,32].
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = RTRIM$( A$ )
  PARAMETER: A$ is a string, LEN >= 0
DESCRIPTION: The string of characters resulting from the value
             associated with A$ by deleting all trailing space characters.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = SEC( X )
  PARAMETER: X  is a number
DESCRIPTION: The secant of X, where X is in radians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = SEEK( X )
  PARAMETER: X  is a number, [1,MAXDEV]
DESCRIPTION: The location of file X; the next record that GET
             or PUT statements will use.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = SEEK( X, Y )
  PARAMETER: X  is a number, [1,MAXDEV]
  PARAMETER: Y  is a number, [MININT,MAXINT]
DESCRIPTION: For file X, move to record number Y; the first record
             number is 1.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = SEG( A$, X, Y )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: X  is a number, [1,MAXLEN]
  PARAMETER: Y  is a number, [0,MAXLEN]
DESCRIPTION: The Y characters of A$, starting from postion X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = SEG$( A$, X, Y )
  PARAMETER: A$ is a string, LEN >= 0
  PARAMETER: X  is a number, [1,MAXLEN]
  PARAMETER: Y  is a number, [0,MAXLEN]
DESCRIPTION: The Y characters of A$, starting from postion X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = SGN( X )
  PARAMETER: X  is a number
DESCRIPTION: The sign of X: -1 if X < 0, 0 if X = 0, and +1 if
             X > 0.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = SHELL( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: The exit code resulting from the execution of an
             operating system command.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = SIN( X )
  PARAMETER: X  is a number
DESCRIPTION: The sine of X, where X is in radians.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = SIND( X )
  PARAMETER: X  is a number
DESCRIPTION: The sine of X, where X is in degrees.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = SING( X )
  PARAMETER: X  is a number
DESCRIPTION: The sine of X, where X is in gradians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = SINH( X )
  PARAMETER: X  is a number
DESCRIPTION: The hyperbolic sine of X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = SIZE( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: The total number of 1KB blockes required to contain
             the file.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = SIZE( ... )
DESCRIPTION: SIZE( arrayname ).  The total number of items in
             the array.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = SLEEP( X )
  PARAMETER: X  is a number
DESCRIPTION: The program pauses for X times the value of OPTION
             SLEEP seconds.  If the result is zero, negative, or more than
             INT_MAX then SLEEP does nothing.  The resolution is implementation
             defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = SNH( X )
  PARAMETER: X  is a number
DESCRIPTION: The hyperbolic sine of X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = SPA( X )
  PARAMETER: X  is a number, [0,MAXLEN]
DESCRIPTION: The string of X blank spaces.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = SPACE( X )
  PARAMETER: X  is a number, [0,MAXLEN]
DESCRIPTION: The string of X blank spaces.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = SPACE$( X )
  PARAMETER: X  is a number, [0,MAXLEN]
DESCRIPTION: The string of X blank spaces.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = SPC( X )
  PARAMETER: X  is a number
DESCRIPTION: The string of X blank spaces.  Only for use within
             the PRINT command.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = SQR( X )
  PARAMETER: X  is a number, >= 0
DESCRIPTION: The non-negative square root of X;  X shall be non-negative.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = SQRT( X )
  PARAMETER: X  is a number, >= 0
DESCRIPTION: The non-negative square root of X;  X shall be non-negative.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = STR( X, Y )
  PARAMETER: X  is a number, [0,MAXLEN]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: The string X bytes long consisting of CHR$(Y).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = STR$( X )
  PARAMETER: X  is a number
DESCRIPTION: The string generated by the print-statement as the
             numeric-representation of the value associated with X.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = STRING( X, Y )
  PARAMETER: X  is a number, [0,MAXLEN]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: The string X bytes long consisting of CHR$(Y).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = STRING$( X, A$ )
  PARAMETER: X  is a number, [0,MAXLEN]
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: The string X bytes long consisting of the first
             character of A$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = STRING$( X, Y )
  PARAMETER: X  is a number, [0,MAXLEN]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: The string X bytes long consisting of CHR$(Y).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = STUFF( X, Y )
  PARAMETER: X  is a number, [MINLNG,MAXLNG]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: Sends Y to hardware address X.  Not supported on
             all platforms.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = TAB( X )
  PARAMETER: X  is a number
DESCRIPTION: The string required to advance to column X.  Only
             for use within the PRINT command.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = TAN( X )
  PARAMETER: X  is a number
DESCRIPTION: The tangent of X, where X is in radians.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = TAND( X )
  PARAMETER: X  is a number
DESCRIPTION: The tangent of X, where X is in degrees.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = TANG( X )
  PARAMETER: X  is a number
DESCRIPTION: The tangent of X, where X is in gradians.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = TANH( X )
  PARAMETER: X  is a number
DESCRIPTION: The hyperbolic tangent of X.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = TI
DESCRIPTION: The time elapsed since the previous midnight, expressed
             in seconds; e.g., the value of TIME at 11:15 AM is 40500.  If
             there is no clock available, then the value of TIME shall be
             -1.  The value of TIME at midnight shall be zero (not 86400).
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = TI$
DESCRIPTION: The time of day in 24-hour notation according to
             ISO 3307.  For example, the value of TIME$ at 11:15 AM is '11:15:00'.
             If there is no clock available, then the value of TIME$ shall
             be '99:99:99'.  The value of TIME$ at midnight is '00:00:00'.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = TIM
DESCRIPTION: The time elapsed since the previous midnight, expressed
             in seconds; e.g., the value of TIME at 11:15 AM is 40500.  If
             there is no clock available, then the value of TIME shall be
             -1.  The value of TIME at midnight shall be zero (not 86400).
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [_] RSTS-11
             [X] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = TIM( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: If X is 0, returns minutes in current hour.  If
             X is 1, returns hours in current day.  If X is 2, returns days
             in current year.  If X is 3, returns years since 1900.  Any other
             value for X is an ERROR.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = TIME
DESCRIPTION: The time elapsed since the previous midnight, expressed
             in seconds; e.g., the value of TIME at 11:15 AM is 40500.  If
             there is no clock available, then the value of TIME shall be
             -1.  The value of TIME at midnight shall be zero (not 86400).
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = TIME( X )
  PARAMETER: X  is a number
DESCRIPTION: The time elapsed since the previous midnight, expressed
             in seconds; e.g., the value of TIME at 11:15 AM is 40500.  If
             there is no clock available, then the value of TIME shall be
             -1.  The value of TIME at midnight shall be zero (not 86400).
             The value of the parameter X is ignored.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = TIME$
DESCRIPTION: The time of day in 24-hour notation according to
             ISO 3307.  For example, the value of TIME$ at 11:15 AM is '11:15:00'.
             If there is no clock available, then the value of TIME$ shall
             be '99:99:99'.  The value of TIME$ at midnight is '00:00:00'.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = TIME$( X )
  PARAMETER: X  is a number
DESCRIPTION: The time of day in 24-hour notation according to
             ISO 3307.  For example, the value of TIME$ at 11:15 AM is '11:15:00'.
             If there is no clock available, then the value of TIME$ shall
             be '99:99:99'.  The value of TIME$ at midnight is '00:00:00'.
             The value of X is ignored.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = TIMER
DESCRIPTION: The time in the system clock in seconds elapsed
             since midnight.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = TOP
DESCRIPTION: The address of the top of available memory.  This
             function is provided for backward compatibility only and it always
             returns a fixed value of 32000.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = TRACE
DESCRIPTION: Turn tracing ON
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: S$ = TRIM$( A$ )
  PARAMETER: A$ is a string, LEN >= 0
DESCRIPTION: The string resulting from removing both leading
             and trailing spaces from A$.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = TROFF
DESCRIPTION: Turn tracing OFF
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = TRON
DESCRIPTION: Turn tracing ON
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = TRUNCATE( X, Y )
  PARAMETER: X  is a number
  PARAMETER: Y  is a number, [MININT,MAXINT]
DESCRIPTION: The value of X truncated to Y decimal digits to
             the right of the decimal point (or -Y digits to the left if Y
             < 0); i.e., IP(X*10^Y)/10^Y.  Y in [-32,32].
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = UBOUND( ... )
DESCRIPTION: UBOUND( arrayname [, dimension] ).  The upper bound
             of the array.  The dimension defaults to 1.  dimension in [1,DIM(arrayname)]
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: S$ = UCASE$( A$ )
  PARAMETER: A$ is a string, LEN >= 0
DESCRIPTION: The string of characters resulting from the value
             associated with A$ by replacing each lower-case-letter in the
             string by its upper-case version.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = UNSAVE( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: Removes the file named in A$.
   VERSIONS:
             [_] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = VAL( A$ )
  PARAMETER: A$ is a string, LEN >= 1
DESCRIPTION: The value of the numeric-constant associated with
             A$, if the string associated with A$ is a numeric-constant. 
             Leading and trailing spaces in the string are ignored.  If the
             evaluation of the numeric-constant would result in a value which
             causes an underflow, then the value returned shall be zero. 
             For example, VAL(' 123.5 ' ) = 123.5, VAL('2.E-99') could be
             zero, and VAL('MCMXVII') causes an exception.
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = VTAB( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: Savme as LOCATE X, 1.
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = WAIT( X )
  PARAMETER: X  is a number
DESCRIPTION: The program pauses for X times the value of OPTION
             SLEEP seconds.  If the result is zero, negative, or more than
             INT_MAX then WAIT does nothing.  The resolution is implementation
             defined.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: N  = WAIT( X, Y )
  PARAMETER: X  is a number, [MININT,MAXINT]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: Waits for the value of (INP(X) AND Y) to become
             nonzero.  Not supported on all platforms.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = WAIT( X, Y, Z )
  PARAMETER: X  is a number, [MININT,MAXINT]
  PARAMETER: Y  is a number, [0,255]
  PARAMETER: Z  is a number, [0,255]
DESCRIPTION: Waits for the value of ((INP(X) XOR Z) AND Y) to
             become nonzero.  Not supported on all platforms.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = WIDTH( X )
  PARAMETER: X  is a number, [0,255]
DESCRIPTION: For console, sets the line width to X. Zero means
             no wrapping will occur.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: N  = WIDTH( X, Y )
  PARAMETER: X  is a number, [0,255]
  PARAMETER: Y  is a number, [0,255]
DESCRIPTION: If X in [MINDEV,MAXDEV] then for file X, sets the
             line width to Y.  If X = 0, sets the console width to Y.  f X
             > MAXDEV, then sets the console rows to X and the line width
             to Y.  A value of zero for Y means no wrapping will occur.
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
============================================================
                    OPERATORS                               
============================================================


------------------------------------------------------------
     SYNTAX: A$ LIKE B$
DESCRIPTION: Compare A$ to the pattern in B$
 PRECEDENCE: 7
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X EQV Y
DESCRIPTION: Bitwise EQV
 PRECEDENCE: 2
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X XOR Y
DESCRIPTION: Bitwise Exclusive OR
 PRECEDENCE: 3
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X XRA Y
DESCRIPTION: Bitwise Exclusive OR
 PRECEDENCE: 3
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X AND Y
DESCRIPTION: Bitwise AND
 PRECEDENCE: 5
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: NOT X
DESCRIPTION: Bitwise NOT
 PRECEDENCE: 6
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X IMP Y
DESCRIPTION: Bitwise IMP
 PRECEDENCE: 1
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X MAX Y
DESCRIPTION: Maximum
 PRECEDENCE: 7
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X MIN Y
DESCRIPTION: Minimum
 PRECEDENCE: 7
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X MOD Y
DESCRIPTION: Integer Modulus
 PRECEDENCE: 10
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [_] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X >< Y
DESCRIPTION: Not Equal
 PRECEDENCE: 7
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X GE Y
DESCRIPTION: Greater than or Equal
 PRECEDENCE: 7
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X >= Y
DESCRIPTION: Greater than or Equal
 PRECEDENCE: 7
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X => Y
DESCRIPTION: Greater than or Equal
 PRECEDENCE: 7
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X LE Y
DESCRIPTION: Less than or Equal
 PRECEDENCE: 7
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X <= Y
DESCRIPTION: Less than or Equal
 PRECEDENCE: 7
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X =< Y
DESCRIPTION: Less than or Equal
 PRECEDENCE: 7
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X EQ Y
DESCRIPTION: Equal
 PRECEDENCE: 7
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X LT Y
DESCRIPTION: Less than
 PRECEDENCE: 7
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X GT Y
DESCRIPTION: Greater than
 PRECEDENCE: 7
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X OR Y
DESCRIPTION: Bitwise OR
 PRECEDENCE: 4
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X NE Y
DESCRIPTION: Not Equal
 PRECEDENCE: 7
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X <> Y
DESCRIPTION: Not Equal
 PRECEDENCE: 7
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X ** Y
DESCRIPTION: Exponential
 PRECEDENCE: 14
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X = Y
DESCRIPTION: Equal
 PRECEDENCE: 7
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X # Y
DESCRIPTION: Not Equal
 PRECEDENCE: 7
   VERSIONS:
             [_] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [_] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X & Y
DESCRIPTION: Concatenation
 PRECEDENCE: 8
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [_] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X + Y
DESCRIPTION: Addition
 PRECEDENCE: 9
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X - Y
DESCRIPTION: Subtraction
 PRECEDENCE: 9
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X > Y
DESCRIPTION: Greater than
 PRECEDENCE: 7
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X \ Y
DESCRIPTION: Integer Division
 PRECEDENCE: 11
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X * Y
DESCRIPTION: Multiplication
 PRECEDENCE: 12
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X / Y
DESCRIPTION: Division
 PRECEDENCE: 12
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: # X
DESCRIPTION: Posation
 PRECEDENCE: 13
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [_] SYSTEM-360
             [X] RSTS-11
             [_] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: + X
DESCRIPTION: Posation
 PRECEDENCE: 13
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: - X
DESCRIPTION: Negation
 PRECEDENCE: 13
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X ^ Y
DESCRIPTION: Exponential
 PRECEDENCE: 14
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [_] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------
     SYNTAX: X [ Y
DESCRIPTION: Exponential
 PRECEDENCE: 14
   VERSIONS:
             [X] Bywater
             [_] DARTMOUTH
             [_] MARK-I
             [_] MARK-II
             [_] SYSTEM-360
             [_] RSTS-11
             [_] SYSTEM-370
             [_] CBASIC-II
             [_] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [_] BASIC-80
             [_] GW-BASIC
             [_] ECMA-116
             [_] QBASIC
             [_] VBX
------------------------------------------------------------
     SYNTAX: X < Y
DESCRIPTION: Less than
 PRECEDENCE: 7
   VERSIONS:
             [X] Bywater
             [X] DARTMOUTH
             [X] MARK-I
             [X] MARK-II
             [X] SYSTEM-360
             [X] RSTS-11
             [X] SYSTEM-370
             [X] CBASIC-II
             [X] ECMA-55
             [X] HANDBOOK1
             [X] HANDBOOK2
             [X] TRS-80
             [X] BASIC-80
             [X] GW-BASIC
             [X] ECMA-116
             [X] QBASIC
             [X] VBX
------------------------------------------------------------



THE END