basic.1

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

        40 next i
        50 print a(5)
        60 rem should print 25

.TP
.B 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.  Strings must be encapsulated with
quote marks.

.TP
.B read VAR { , VAR }

Read data from the DATA statements contained in the
program. List items can be either string or numeric
variables. Reading past the end the last DATA statement
generates an error.

.TP
.B restore { LINENUM }

The RESTORE statement causes the next READ to use the
first DATA statement in the program.  If a LINENUM is
given then the DATA statement on or after that
particular line is used next.

.TP
.B rem or "`"

A remark or comment statement.  Ignored by the program
during execution, however a REM statement can be the
target of a GOTO or GOSUB.

.TP
.B open STRINGEXPR for { input|output|append } as # FNUM

Open a file. The { input|output|append } parameter
specifies whether the file is to be read, written or
appended.  If STRINGEXPR is "stdin" for input or
"stdout" for output then the console will be used
instead of a file.  A "file not found" error will
occur if a non-existant file is specified in an OPEN
for input statement.  FNUM must be an integer value
between 0 and 8.

.TP
.B open STRINGEXPR for random as # FNUM len = VAL

Opens a random access file.  Only GET and PUT statement
are allowed to read and write random access files.

.TP
.B open ... else goto LINENUM

See OPEN command.
LINENUM is the line to which control is transferred if
an error in opening a file occurs.  The variable ERL is
set to the line number on which the file open error
occured.

.TP
.B close # FNUM

Close a file. Releases the file descriptor and flushes
out all stored data.

.TP
.B def fnNAME ( VAR { , VAR } ) = EXPR

Define a user definable function.  Obsolete.

Example:
        10 def fnplus(x,y) = x+y
        20 print fnplus(3,5)
        30 rem - should print 8

.TP
.B mat ARRAY-VAR = EXPR

Fills a 1 or 2 dimensional array with a constant
value given by EXPR.

.TP
.B mat ARRAY-VAR = ARRAY-VAR

Copys a 2 dimensional array.  The dimensions
must match.

.TP
.B mat ARRAY-VAR = transpose ARRAY-VAR

Transposes a 2 dimensional array.  The dimensions of
the first array must correspond to the transpose of
the dimensions of the second array.

.TP
.B mat ARRAY-VAR = ARRAY-VAR { + | * } { EXPR | ARRAY-VAR }

Adds or multiplies a 2 dimensional array by either
an expression or another array.  The dimensions must
be appropriate for matrix addition or matrix
multiplication.

.TP
.B mat origin { 0 | 1 }

Sets the matrix index origin to either 0 or 1 for all
MAT statements, including fill.  Defaults to 1.

.TP
.B type CLASSNAME

Creates a structure definition type.  Each field
requires a separate line.  Legal types are string,
integer, longint and double.  The definition must
conclude with an END TYPE statement.  Use the
DIM AS NEW statement to create records containing
the structure specified by a TYPE statement.

Example:
        300 type person
        310   name as string * 32
        311     rem  31 chars in length
        320   age as integer
        312     rem  2 byte integers
        330   weight as double
        331     rem  8 byte doubles
        340 end type
        400 dim friend1 as new person
        410 friend1.name = "Mark"
        420 friend1.age = 13
        430 print friend1.name, friend1.age
.PP
.TP
.B class CLASSNAME { extends SUPERCLASSNAME }

Creates a class definition.  Class definitions can then
be used to create objects with member functions (also
called methods.)  Classes inherit members from
superclasses (single inheritance.)

Example:
    CLASS bar
        y AS integer
        z AS PRIVATE double   ' private data
        s AS PUBLIC string    ' public keyword optional
        SUB blah(v)           ' public member function
            this.y = v + 7
        END SUB
    END CLASS

    DIM b AS NEW bar        ' create object b
    CALL b.blah(1)          ' send message "blah(1)" to b

CLASS and TYPE definitions are global, and cannot be
nested inside other class definitions or subroutines.

.TP
.B dim VAR { ( INT ) } as new CLASSNAME

Create a record (TYPED-VAR) or object using a
previously defined structure definition type created
by TYPE...END TYPE or CLASS..END CLASS.  Optionally
creates an array of records or objects.

.TP
.B erase VAR

Un-dimensions a dimensioned array.  Frees memory.

.TP
.B option degrees

Changes the trigonometric functions to take parameters
and return results in degrees instead of radians.

.TP
{ let } mid$( STRINGVAR, EXPR1, EXPR2 ) = STRINGEXPR

Replace the sub-string in STRINGVAR, starting at
character position EXPR1, with character length EXPR2,
with the (EXPR2 in length) string STRINGEXPR.

.TP
{ let } field$( STRINGVAR, VAL { ,STRINGVAL } ) = STRINGEXPR

Replace the N-th field of STRINGVAR with STRINGEXPR.

.TP
.B poke ADDR_EXPR, DATA_EXPR

Poke a byte into a memory location. Unreasonable
addresses can cause bus or segmentation errors.

.TP
.B push VAR { , VAR ... }

Pushes one or more expressions or variables onto an
internal stack.  Expressions can be returned using the
POP function; variables can be returned by using the
POP statement.

.TP
.B pop VAL

POP statement (see also POP function). Pops VAL
variables off the internal stack, restoring the value
of those variables to their pushed values.

.TP
.B exec(STRINGEXPR)

Executes STRINGEXPR as a statement or command. 
e.g. exec("print " + "x") will print the value of x.
.PP
.SH NUMERIC FUNCTIONS
.PP

.TP
.B sgn(VAL)

Returns the sign of the parameter value.  Returns 1 if
the value is greater than zero , zero if equal to zero.
-1 if negative.

.TP
.B abs(x)

Returns the absolute value of x.

.TP
.B int(x)

Returns the integer value of x.  Truncates toward negative infinity.
The absolute value of x must be less than 2^31-1.
The usage int(x, 0) truncates towards zero.

.TP
.B floor(x)

Returns the integer value of x.
Truncates toward negative infinity.

.TP
.B sqr(x)

Returns the square root of x.

.TP
.B log(x)

Returns the natural logarithm of x.

.TP
.B log10(x)

Returns the logarithm base 10 of x.

.TP
.B exp(x)

Returns e^x. e=2.7182818...

.TP
.B sin(x)
.TP
.B cos(x)
.TP
.B atn(x)
.TP
.B atn(x,y)

Trigonometric functions: sin, cosine and arctangent. 

.TP
.B pi

Returns pi, 3.141592653589793... 

.TP
.B rnd ( EXPR )

Returns an integer pseudo-random number between 0 and
int(EXPR)-1 inclusive. If EXPR is 1, then returns a
rational number between 0 (inclusive) and 1.  If EXPR
is negative then EXPR seeds the random number generator.

.TP
.B randomize EXPR

Seeds the random number generator with the integer
EXPR. The pseudo-random number generator should return
the same sequence when seeded with the same start
value.  The actual sequence may be system dependant.

.TP
.B len( STRINGEXPR )

Returns the length of the string STRINGEXPR.

.TP
.B len( TYPED-VAR )

Returns the length, in bytes, of a typed record
(one created by DIM AS).

.TP
.B val( STRINGEXPR | EXPR )

Value of the expression contained in a STRINGEXPR or
EXPR.  STRINGEXPR may be a string literal, variable,
function, or expression.

For example, VAL("1 + sqr(4)") yields 3.

.TP
.B asc( STRINGEXPR )

Returns the ascii code for the first character of
STRINGEXPR.  A null string returns zero.

.TP
.B instr(a$, b$ { , VAL } )

Returns the position of the substring b$ in the
string a$ or returns a zero if b$ is not a substring.
VAL is an optional starting position in a$

.TP
.B ubound( VAR [, EXPR ] )

If VAR is a dimensioned array, returns the maximum
legal subscript of the first dimension of that array,
else returns 0.  Use EXPR to return other dimensions.

.TP
.B isarray( VAR )

If VAR is a dimensioned array, returns the number
of dimensions, otherwise returns 0.

.TP
.B fgetbyte( FILENUM )

Reads one byte from the open file specified by FILENUM
and returns an unsigned numeric value [0..255].

.TP
.B eof(FILENUM)

Returns true if the the last INPUT statement, INPUT$
or FGETBYTE function call which referenced the text
file specified by FILENUM tried to read past the end
of file. (Note that reading the last line of a file
will not read past the eof mark.  A subsequent read is
needed to set the EOF flag to true.  Reading past the
end-of-file will not report an error.)

.TP
.B pop

POP function (see also POP statement). Pops one variable
value off the stack and returns that value (string or
numeric).

(POP can be used as either a statement (with a
parameter) or a function (no parameter). Note that the
POP function, unlike the POP statement, does not
restore the value of the variable pushed, but only
returns the pushed value.  This use of the POP
statement is different from the Applesoft usage.)

.TP
.B peek( ADDR { , SIZE_VAL } )

Returns the value of the byte in memory at address ADDR.
If SIZE_VAL is 2 or 4, returns the value of the 16-bit
or 32-bit word respectively (if correctly aligned).
If SIZE_VAL is 8, returns the value of the numeric
variable located at ADDR.  (peek(varptr(x),8) == x)

.TP
.B varptr( VAR | STRINGVAR )

Returns the memory address of a variable.

.TP
.B erl

Returns the line number of the last error.  Zero if the
error was in immediate mode.  The variable errorstatus$
gives the error type.

.TP
.B timer

Returns a numeric value of elapsed of seconds from the
computers internal clock.
.PP
.SH STRING FUNCTIONS
.PP

.TP
.B x$ + y$

String concatenation.

String concatenation (and the MID$, LEN and INSTR
functions) can handle strings of up to 32766 characters
in length (if the memory available to the program
permits).

.TP
.B chr$(VAL)

Returns the ascii character corresponding to the value
of VAL.

.TP
.B str$( VAL { , EXPR } )

Returns a string representation corresponding to VAL.
If EXPR is present then the string is padded to that
length.

.TP
.B format$( VAL , STREXPR )

Returns the string representation of VAL formatted
according to the format string STREXPR. The format
string STREXPR uses the same formatting syntax as the
PRINT USING statement.

.TP
.B inkey$

Return one character from the keyboard if input is
available. Returns a zero length string { "" } if no
keyboard input is available.  Non-blocking.  Can be
used for keyboard polling.

.TP
.B input$( EXPR { , FILENUM } )

Returns EXPR characters from file FILENUM. If f is not
present then get input from the console keyboard.

.TP
.B mid$( a$, i { , j } )