basic.1

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

.\" Copyright (c) 1991, 1992, 1993, 1994 Free Software Foundation    -*-Text-*-
.\" See section COPYING for conditions for redistribution
.\"
.\" Set up \*(lq, \*(rq if -man hasn't already set it up.
.if @@\*(lq@ \{\
.	ds lq "
.	if t .ds lq ``
.	if !@@\(lq@ .ds lq "\(lq
.\}
.if @@\*(rq@ \{\
.	ds rq "
.	if t .ds rq ''
.	if !@@\(rq@ .ds rq "\(rq
.\}
.de Id
.ds Rv \\$3
.ds Dt \\$4
..
.de Sp
.if n .sp
.if t .sp 0.4
..
.Id $Id: gcc.1,v 1.4 2002/01/28 23:19:12 pesch Exp $
.TH BASIC 1 "\*(Dt" "chipmunk-basic" "chipmunk-basic"
.SH NAME
.B basic
Chipmunk BASIC - 'BASIC' language interpreter
.SH SYNOPSIS    ( UNIX )
.B basic 
.RI "[ " filename " ]"

.SH DESCRIPTION

Chipmunk basic is an interpreter for the BASIC programming
language.

If a filename parameter is given on the command line,
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; but Basic
programs do not require line numbers when run from files.
See below for the commands, statements and functions that
the Basic interpreter recognizes.

.SH FLAGS

none

.SH COMMANDS

Standard mumbleSoft-like Basic Commands:

.TP
.B 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.
.PP
.TP
.B save STRINGEXPR

Save the current program to the named file.

.TP
.B new

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

.TP
.B clear

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

.TP
.B run { LINENUM }
.TP
.B 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.

.TP
.B 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.

.TP
.B 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.

.TP
.B list

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

.TP
.B list 1-3
List lines 1 to 2

.TP
.B list -2
List lines up to 1

.TP
.B list 1
List line 1

.TP
.B list 2-
List lines from 2 on

.TP
.B 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.

.TP
.B 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.
 
.TP
.B edit LINENUM

Brings up a very Old-style line editor.

Edit a single line.  Enter return to finish.  If the
exit from edit mode is via a cntrl-c or 'q', then do
not change the line.
        i       insert till ESC
        x       delete one char
        A       append to end of line

.TP
.B del LINENUM [ - LINENUM ]

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

.TP
.B exit
.TP
.B exit ( VAL )
.TP
.B bye
.TP
.B quit
 
Terminates the basic interpreter, ending program
execution and closing all files.  Optionally return
exit status to OS shell.

.PP
.SH STATEMENTS
.PP

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

.TP
.B print  VAL | STRINGVAL { [ , | ; ] VAL ... } { ; }
.TP
.B ?      VAL | STRINGVAL { [ , | ; ] VAL ... } { ; }
.TP
.B 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.

.TP
.B 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
        
.TP
.B input  STRINGVAR | VAR  { , VAR }
.TP
.B input  "prompt"; { STRINGVAR | VAR  { , VAR } }
.TP
.B 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.

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

.TP
.B get STRINGVAR

Gets one character from the console keyboard.  Blocking.

.TP
.B fputbyte VAL, # FNUM

Writes one byte to the file specified by FNUM.

.TP
.B get # FNUM, VAL, TYPED-VAR

Reads one record from a random access file into VAR.

.TP
.B put # FNUM, VAL, TYPED-VAR

Write one record to a random access file from VAR.

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

.TP
.B end

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

.TP
.B stop

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

.TP
.B if EXPR then STATEMENT { : STATEMENT } { : else STATEMENT }
.TP
.B if EXPR then LINENUM
.TP
.B 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.

If the condition is true and there is no THEN on the
same line, statements are executed until a line
with an ENDIF is found.  (block IF() ... ENDIF)

.TP
.B 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

.TP
.B 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.

.TP
.B exit for

Exits the current FOR-NEXT loop.

.TP
.B 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.

.TP
.B 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.

.TP
.B exit while

Exits the current WHILE-WEND loop.

.TP
.B 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.

.TP
.B return

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

.TP
.B 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.

.TP
.B on EXPR   goto  LINENUM { , LINENUM ... }
.TP
.B 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.

.TP
.B 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.

.TP
.B 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.
.PP
.TP
.B 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
.PP
.TP
.B 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)
        20 for i=0 to 10
        30   a(i) = i^2