LEGEND

ID	NAME	DESCRIPTION
B15	BYWATER	Bywater BASIC 3
B93	BYWATER-2	Bywater BASIC 2
S70	CALL/360	SBC CALL/360 Mainframe BASIC
C77	CBASIC-II	CBASIC-II for CP/M
D64	DARTMOUTH	Dartmouth DTSS BASIC
E78	ECMA-55	ANSI Minimal BASIC
E86	ECMA-116	ANSI Full BASIC
G74	GCOS	GE 600 Mainframe BASIC
H14	HAARDT	bas 2.4 by Michael Haardt
HB1	HANDBOOK1	The BASIC Handbook, 1st Edition
HB2	HANDBOOK2	The BASIC Handbook, 2nd Edition
H80	HEATH	Heath Benton Harbor BASIC
G65	MARK-I	GE 265 Mainframe BASIC
G67	MARK-II	GE 435 Mainframe BASIC
M80	MBASIC	Microsoft BASIC-80 for Xenix
D73	PDP-8	DEC PDP-8 BASIC
D70	PDP-11	DEC PDP-11 BASIC
R86	RBASIC	Micronics RBASIC for 6809 FLEX
D71	RSTS-11	DEC RSTS-11 BASIC-PLUS
I70	SYSTEM/360	IBM System/360 Mainframe BASIC
I73	SYSTEM/370	IBM System/370 Mainframe BASIC
T80	TRS-80	TRS-80 Model I/III/4 LBASIC
V09	VINTAGE	Vintage BASIC 1.0.1
T79	XBASIC	TSC XBASIC for 6800 FLEX

DETAILS

FUNCTION

B15

B93

S70

C77

D64

E78

E86

G74

H14

HB1

HB2

H80

G65

G67

M80

D73

D70

R86

D71

I70

I73

T80

V09

T79

N = ABS( X )

N = ACOS( X )

N = ACS( X )

N = ACSD( X )

N = ACSG( X )

N = ANGLE( X, Y )

N = ARCCOS( X )

N = ARCSIN( X )

N = ARCTAN( X )

N = ARGC

S$ = ARGT$( X )

N = ARGV( X )

S$ = 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

S$ = BIN$( X )

S$ = BIN$( X, Y )

N = CATALOG

N = CATALOG( A$ )

N = CCUR( X )

N = CDBL( X )

N = CEIL( X )

S$ = CHAR( X, Y )

S$ = CHAR$( X )

N = CHDIR( A$ )

S$ = CHR( X )

S$ = CHR$( X )

N = CIN( X )

N = CINT( X )

N = CLG( X )

N = CLK( X )

S$ = CLK( X )

S$ = CLK$

N = CLNG( X )

N = CLOG( X )

N = CLOSE

N = CLOSE( X )

N = CLS

N = CNTRL( X, Y )

N = CODE( A$ )

N = COLOR( X, Y )

S$ = COMMAND$

S$ = COMMAND$( X )

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 )

S$ = CUR( X, Y )

N = CVC( A$ )

N = CVD( A$ )

N = CVI( A$ )

N = CVL( A$ )

N = CVS( A$ )

S$ = DAT$

N = DATE

S$ = DATE$

S$ = DATE$( X )

N = DEG

N = DEG( X )

N = DEGREE

N = DEGREE( X )

N = DET

N = DIGITS( X )

N = DIGITS( X, Y )

N = DIM( ... )

N = DPEEK( X )

N = DPOKE( X, Y )

S$ = EDIT$( A$, X )

N = ENVIRON( A$ )

S$ = ENVIRON$( A$ )

N = EOF( X )

N = EPS( X )

N = ERL

N = ERR

S$ = ERR$

N = ERRL

N = ERRN

N = ERROR( X )

N = ERROR( X, A$ )

S$ = ERROR$

N = EXAM( X )

N = EXEC( A$ )

N = EXF( ... )

N = EXP( X )

N = FALSE

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( X )

N = FREE( A$ )

N = FREEFILE

N = GET( X )

N = GET( X, Y )

N = GRAD

N = GRADIAN

N = HCS( X )

N = HEX( A$ )

S$ = HEX$( X )

S$ = HEX$( X, Y )

N = HOME

N = HSN( X )

N = HTN( X )

S$ = INCH$

N = INDEX( A$, B$ )

N = INITIALIZE

S$ = INKEY$

N = INP( X )

S$ = INPUT$( X )

S$ = INPUT$( X, Y )

N = INSTR( A$, B$ )

N = INSTR( A$, B$, X )

N = INSTR( X, A$, B$ )

N = INT( X )

N = IP( X )

S$ = KEY

S$ = KEY$

N = KILL( A$ )

N = LBOUND( ... )

S$ = LCASE$( A$ )

S$ = LEFT( A$, X )

S$ = LEFT$( A$, X )

N = LEN( A$ )

N = LGT( X )

S$ = LIN( X )

N = LN( X )

N = LNO( X )

N = LOC( X )

N = LOCATE( X, Y )

N = LOCK( X )

N = LOF( X )

N = LOG( X )

N = LOG10( X )

N = LOG2( X )

N = LOGE( X )

S$ = LOWER$( A$ )

N = LPOS

S$ = LTRIM$( A$ )

N = LTW( X )

N = LWIDTH( X )

N = MATCH( A$, B$, X )

S$ = MAX( A$, B$ )

N = MAX( X, Y )

N = MAXBYT

N = MAXCUR

N = MAXDBL

N = MAXDEV

N = MAXINT

N = MAXLEN

N = MAXLEN( A$ )

N = MAXLNG

N = MAXLVL

N = MAXNUM

N = MAXSNG

N = MEM

S$ = MID( A$, X )

S$ = MID( A$, X, Y )

S$ = MID$( A$, X )

S$ = MID$( A$, X, Y )

N = MIN( X, Y )

S$ = MIN( A$, B$ )

N = MINBYT

N = MINCUR

N = MINDBL

N = MINDEV

N = MININT

N = MINLNG

N = MINNUM

N = MINSNG

S$ = MKC$( X )

S$ = MKD$( X )

N = MKDIR( A$ )

S$ = MKI$( X )

S$ = MKL$( X )

S$ = MKS$( X )

N = MOD( X, Y )

N = NAME( A$, B$ )

N = NAME( ... )

N = NOFLOW

N = NOTRACE

N = NULL( X )

N = NUM

N = NUM( A$ )

S$ = NUM$( X )

S$ = OCT$( X )

S$ = OCT$( X, Y )

N = OPEN( A$, X, B$ )

N = OPEN( A$, X, B$, Y )

N = ORD( A$ )

N = OUT( X, Y )

N = PAD( X )

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( X )

N = POS( A$, B$ )

N = POS( A$, B$, X )

N = PRECISION( X )

N = PTR( ... )

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$ )

S$ = REPEAT$( X, A$ )

S$ = REPEAT$( X, Y )

N = RESET

N = RESIDUE

S$ = RIGHT( A$, X )

S$ = RIGHT$( A$, X )

N = RMDIR( A$ )

N = RND

N = RND( X )

N = ROUND( X, Y )

S$ = RTRIM$( A$ )

N = SCALE( X )

N = SEC( X )

N = SEEK( X )

N = SEEK( X, Y )

N = SEG( X )

S$ = SEG( A$, X, Y )

S$ = SEG$( A$, X, Y )

N = SGN( X )

N = SHELL( A$ )

N = SIN( X )

N = SIND( X )

N = SING( X )

N = SINH( X )

N = SIZE( A$ )

N = SIZE( ... )

N = SLEEP( X )

N = SNH( X )

S$ = SPA( X )

S$ = SPACE( X )

S$ = SPACE$( X )

S$ = SPC( X )

N = SQR( X )

N = SQRT( X )

S$ = STR( X, Y )

S$ = STR$( X )

S$ = STRING( X, Y )

S$ = STRING$( X, A$ )

S$ = STRING$( X, Y )

S$ = STRIP$( A$ )

N = STUFF( X, Y )

S$ = TAB( X )

N = TAN( X )

N = TAND( X )

N = TANG( X )

N = TANH( X )

N = TI

S$ = TI$

N = TIM

N = TIM( X )

N = TIME

N = TIME( X )

S$ = TIME$

S$ = TIME$( X )

N = TIMER

N = TOP

N = TRACE

N = TRACE( X )

S$ = TRIM$( A$ )

N = TROFF

N = TRON

N = TRUE

N = TRUNCATE( X, Y )

N = UBOUND( ... )

S$ = UCASE$( A$ )

N = UNLOCK( X )

N = UNSAVE( A$ )

S$ = UPPER$( A$ )

N = USR( ... )

N = USR0( ... )

N = USR1( ... )

N = USR2( ... )

N = USR3( ... )

N = USR4( ... )

N = USR5( ... )

N = USR6( ... )

N = USR7( ... )

N = USR8( ... )

N = USR9( ... )

N = UUF( ... )

N = VAL( A$ )

N = VARPTR( ... )

N = VTAB( X )

N = WAIT( X )

N = WAIT( X, Y )

N = WAIT( X, Y, Z )

N = WIDTH( X )

N = WIDTH( X, Y )

N = ZONE( X )

N = ZONE( X, Y )