basic-man.txt

比较早的一款BASIC解释器 可作为学习BASIC解释器的一个参考

                            Chipmunk Basic Man Page
     _________________________________________________________________


    BASIC(1)            Chipmunk Basic v3.6.1                   BASIC(1)


        Chipmunk BASIC - 'BASIC' language interpreter


    SYNOPSIS    ( UNIX )

        basic [ filename ]

    DESCRIPTION

        Chipmunk basic is an interpreter for the BASIC language. If
        a filename parameter is given, then the named program file
        is loaded into memory and run.  

        Basic commands and statements can be entered and interpreted
        in immediate mode or executed as program statements when the
        Basic program is run.  A built-in line number based editor
        allows program input from the console keyboard.  See below
        for the commands and statements which the interpreter
        recognizes.

    FLAGS

        none

    COMMANDS
        
        Standard mumbleSoft-like Basic Commands:

        load STRINGEXPR

                Load a program into memory from the named file. The
                program previously in memory is erased.  All files are
                closed and all variables are cleared.  Lines beginning
                with the '#' character will be treated as comments. 
                All other lines in the file must begin with a line
                number.  Duplicate line numbers are not allowed.


        save STRINGEXPR

                Save the current program to the named file.

        new

                Erase the program in memory.  All files are closed and
                all variables are cleared.

        clear

                All  variables are cleared.  All arrays and string
                variables are deallocated.

        run { LINENUM }
        run { STRINGEXPR { , LINENUM } }

                Begin execution of the program at the first line, or at
                the specified line.  All variables are cleared.  If a
                STRINGEXPR is given then the BASIC program with that
                name file is loaded into memory first.  Program lines
                are executed in line number order.

        cont

                CONTinue execution of the program on the next statement
                after the statement on which the program stopped
                execution due to a STOP command or an error.  See BUGS
                section.

        LINENUM { TEXT }

                Enters a program line.  If a program line with
                line number LINENUM exists, then it is replaced.
                If no TEXT is given, the the program line with
                line number LINENUM is deleted.

        list
                List the whole program.
                Line numbers above 999999999 will not list.

        list 1-3
                List lines 1 to 2

        list -2
                List lines up to 1

        list 1
                List line 1

        list 2-
                List lines from 2 on

        merge STRINGEXPR

                Loads a program into memory.  The previous program
                remains in memory; variables are not cleared.  If a
                line exists in both programs, the new merged line
                overwrites the old one.

        renum STRINGEXPR VAL { , VAL { , VAL { , VAL} } }

                Renumber program lines.  By default, the new sequence is
                10,20,30,... The first argument is a new initial line
                number; the second argument is the increment between
                line numbers. The third and fourth arguments, if
                present, specify a limiting range of old line numbers
                to renumber.  RENUM can be used to move non-overlapping
                blocks of code.
         
        edit LINENUM

                Edit a single line. If the exit from the edit is via a
                cntrl-c then the program line is not modified.
                        i       insert till  key
                        x       delete one char
                        A       append to end of line

        del LINENUM [ - LINENUM ]

                Delete a line or specified range of lines. If not found
                then no lines will be deleted.

        exit
        bye
        quit

                Terminates the basic interpreter, ending program
                execution and closing all files.


    STATEMENTS

        { let } VAR = EXPR

                Assign a value to a variable.  Variable names can be up
                to 31 significant characters, consisting of letters,
                digits, underscores, and an ending dollar sign.
                Variable names are case insensitive.  Variables can
                hold real numbers (IEEE double) or strings of up to 254
                characters.  If the variable name ends with a "$" it
                holds strings, otherwise it holds numbers.  If a
                statement starts with a variable name then an implied
                LET is assumed.

        print  VAL | STRINGVAL { [ , | ; ] VAL ... } { ; }
        ?      VAL | STRINGVAL { [ , | ; ] VAL ... } { ; }
        print # FNUM, VAL ...

                This command will print its parameters tab delimited.
                If a semi-colon is used between parameters then no tab
                is inserted between the parameters.  The print
                output is terminated with a carriage return unless the
                parameter list ends with a semi-colon.  If a file
                descriptor is given then output is redirected to the
                given file.  If a

                        tab(VAL);

                is found in a print statement, then print output will
                skip to the horizontal position specified by VAL.

        print { # FNUM, } using STRINGVAL ; VAR { [ , | ; ] VAR ... }

                Prints formatted numbers.  Legal characters for the
                format string STRINGVAL are: + * $ # . E+ and trailing
                spaces.

                Examples:

                        print using "**$###.##"; 1.23  :' ****$1.23
                        print using "###.##"; 2.12345  :'   2.12
                        print using "#.##E+##"; 2345.6 :'   2.35E+03

        input  STRINGVAR | VAR  { , VAR }
        input  "prompt ", { STRINGVAR | VAR  { , VAR } }
        input  { # FNUM , } { STRINGVAR | VAR { , VAR } }

                Input from the console or from the file specified by
                FNUM. If the input is from the console then a prompt
                string can optionally be printed before input.

                *** NOTE ***

                All input to string variables is "line input"; a whole
                input line will be read into one string variable.  The
                number of comma seperated numeric values in the input
                data must be less than or equal to the number of
                numeric variables in the INPUT statement.  This INPUT
                usage is different from other versions Basic.

        get STRINGVAR

                Gets one character from the console keyboard.
                Blocking (waits for a character).

        fputbyte VAL, # FNUM

                Writes one byte to the file specified by FNUM.

        get # FNUM, VAL, TYPED-VAR

                Reads one record from a random access file into VAR.

        put # FNUM, VAL, TYPED-VAR

                Write one record to a random access file from VAR.

        cls
                Clear the terminals screen.  Leaves the cursor in the
                upper left corner.  For Applesoft BASIC fans, the
                "home" command will also do this.

        end

                Terminates program execution and returns to the command
                prompt.  Not required.

        stop

                Stops the execution of the program and returns to
                the command prompt.  Prints a "Break..." message.

        if EXPR then STATEMENT { : STATEMENT } { : else STATEMENT }
        if EXPR then LINENUM
        if (EXPR)

                The IF statement.  If the condition is true then the
                STATEMENTS after the THEN are executed and the
                statements after the ELSE are skipped.  If the
                condition is false then the statements after the "else"
                are executed instead.  If the item after "then" is a
                line number then a goto is executed.

                block IF () : ... : ENDIF

                If these is no THEN keywork on the same line as
                the IF statement, and the condition is true, then
                statements are executed until a line with an ELSE
                or ENDIF is found.  If an ELSE is found first the
                following statements are skipped until an ENDIF is
                found.  If the condition is false, then statements
                are skipped until and ELSE is found.  IF .. ENDIF
                blocks may be nested.


        for VAR = EXPR to EXPR { step EXPR }

                Beginning of a FOR-NEXT loop.  It takes a starting
                value, a limit and an optional step argument.  If the
                step value is negative, the variable counts down.  The
                body of the loop is not executed if the end condition
                is true initially.

                Example:
                        for i=1 to 10 : print i, : next i
                        rem prints the numbers from 1 through 10

        next { VAR }

                End of a FOR-NEXT loop.  If the termination conditions
                are met then execution falls through to the following
                statement, otherwise execution returns to the statement
                following the FOR statement with the corresponding
                index variable. If there no index variable parameter,
                the innermost FOR loop is used.

        exit for

                Exits the current FOR-NEXT loop.

        while { EXPR }

                Start of a WHILE loop. The loop is repeated until EXPR
                is false. If EXPR is false at loop entry, then the loop
                is not executed . A WHILE loop must be terminated by a
                balancing WEND statement.

        wend { EXPR }

                Terminating statement of a WHILE loop.  If EXPR is true
                then exit the loop.  Only one WEND is allowed for each
                WHILE.  A WHILE-WEND loop without a condition will loop
                forever.

        exit while

                Exits the current WHILE-WEND loop.

        gosub LINENUM

                Transfer command to a line number. Save return address
                so that the program can resume execution at the
                statement after the "gosub" command.  The recursion
                depth is limited only by available memory.

        return

                Returns from the most recently activated subroutine
                call (which must have been called by GOSUB).

        goto LINENUM

                This statement will transfer control to the line number
                specified.  If the program is not running, then this
                command will begin execution at the specified line
                without clearing the variables.  An "Undefined line"
                error will occur if LINENUM doesn't exist in the
                program.

        on EXPR   goto  LINENUM { , LINENUM ... }
        on EXPR   gosub LINENUM { , LINENUM ... }
                This command will execute either a goto or a gosub to
                the specified line number indexed by the value of EXPR.
                If EXPR is larger than the number of LINENUMs, then
                control passes to the next statement.

        on error  goto  LINENUM

                If the error form is used, only one linenumber is
                allowed.  LINENUM is the line to which control is
                transferred if an error occurs.  A GOTO or CONT
                statement can be used to resume execution.  An error
                inside a named SUB subroutine cannot be resumed from
                or CONTinued.

        sub NAME ( VAR { , VAR ... } }

                Subroutine entry.  May be called by a CALL statement or
                by NAME. A SUB subroutine must be exited by a RETURN or
                END SUB statement.  There should be only one RETURN or
                END SUB statement per SUB definition.  The variables in
                the VAR list become local variables. String and numeric
                arguments are passed by value; array arguments must be
                pre-dimensioned and are passed by reference.

                Example:
                        110  x = foo (7, j)  : rem Pass 7 and j by value.
                        ...
                        2000 sub foo (x,y,z) : rem z is a local variable
                        2010   print x       : rem prints 7
                        ...
                        2080   foo = y+1     : rem return value
                        2090 end sub

                Subroutine definitions may not be nested.


        select case EXPR

                Multi-way branch.  Executes the statements after
                the CASE statement which matches the SELECT CASE
                expression, then skips to the END SELECT statement.
                If there is no match, and a CASE ELSE statement is
                present, then execution defaults to the statements
                following the CASE ELSE.

                Example:
                        200 select case x
                        210   case 2
                        ...
                        230   case 3, 4
                        ...
                        270   case else
                        ...
                        290 end select


        dim VAR( d { , d { , d } } ) { , VAR( d { , d { , d } } ) ... }

                Dimension an array or list of arrays (string or numeric). 
                A maximum of 4 dimensions can be used. The maximum
                dimension size is limited by available memory. Legal
                array subscripts are from 0 up and including the
                dimension specified; d+1 elements are allocated.  All
                arrays must be dimensioned before use.

                Example:
                        10 dim a(10)  : rem  An 11 element array.
                        20 for i=0 to 10
                        30   a(i) = i^2
                        40 next i
                        50 print a(5) : rem  Should print 25

        data ITEM { , ITEM }

                DATA statements contain the data used in the READ
                statements. Items must be separated by commas.  The
                items may be either numeric or string expressions,
                corresponding to the type of variable being read.
                Reading the wrong kind of object produces a "Type
                mismatch" error.

                * IMPORTANT DIFFERENCE from other Basic versions *

                String data must be encapsulated with quote marks.


        read VAR { , VAR }

                Read data from the DATA statements contained in the
                program. List items can be either string or numeric