Seed7 Program: Basic

Basic

Bas7 is a BASIC interpreter which is compatible to GW-BASIC and other old BASIC dialects.

Bas7 is designed to interpret programs from the line number era of BASIC. Structured 'IF', 'DO' and 'SELECT' statements and programs without line numbers are also supported. Unlike many other BASIC interpreters it does not try to introduce incompatible features. Bas7 concentrates on backward compatibility instead. Bas7 can be used to analyze spaghetti code. The option -l causes the generation of a log file. Since spaghetti code is very common in old BASIC programs, logging can be very useful. As porting tool Bas7 hopefully helps to port historic programs to modern programming languages like Seed7. Bas7 can be called from the command line:

tm@penguin:~/seed7_5/prg$ ls -l hello.bas
-rw-r--r-- 1 tm tm 66 2008-01-17 08:54 hello.bas
tm@penguin:~/seed7_5/prg$ cat hello.bas
100 PRINT "Hello, world!"
110 INPUT "Press return to continue",a$
tm@penguin:~/seed7_5/prg$ s7 bas7 -l hello

The command window is cleared and contains:

Hello, world!
Press return to continue

After pressing return the program is finished. The log can be found in the file bas7.log:

tm@penguin:~/seed7_5/prg$ cat bas7.log
  100 PRINT "Hello, world!"
  110 INPUT "Press return to continue",a$

load_prog finished
100 PRINT "Hello, world!"
110 INPUT "Press return to continue"
110 INPUT A$ <- ""
END OF PROGRAM REACHED
tm@penguin:~/seed7_5/prg$

To avoid adding an 'INPUT' statement at the end of a program it is possible to call bas7 with the -p option:

s7 bas7 -p foo.bas

That way bas7 asks for a confirmation at the end of the program:

=== Program finished ===
Press return to continue

The following options are supported by bas7:

	-p		Ask for a prompt at the end of the program
	-l		List program and write log of executed statements

The Bas7 interpreter implements the following functions and statements ( ** means recognized but not implemented):

ABS, ACCEPT, ASC, ATN, **BEEP, BLOAD, **BSAVE, **CALL, CASE, CDBL, CHAIN, CHR$, CINT, **CIRCLE, CLEAR, CLNG, CLOSE, CLS, **COLOR, COMMAND$, **COMMON, CONST, COS, CSNG, CSRLIN, CVD, CVDMBF, CVI, CVL, CVS, CVSMBF, DATA, DATE$, **DECLARE, DECR, DEF FN, **DEF SEG, DEFDBL, DEFINT, DEFLNG, DEFSNG, DEFSTR, DELAY, DIM, DISPLAY, DO, DO UNTIL, DO WHILE, **DRAW, ELSE, ELSEIF, END, ENDIF, ENVIRON$, EOF, **ERASE, ERL, ERR, ERROR, EXIT DO, EXIT FOR, EXP, FIELD, FIX, **FLASH, FOR, FRE, FREEFILE, **FUNCTION, GET, GET#, GOSUB, GOSUB OF, GOTO, GOTO OF, GR, HEX$, HGR, HOME, HPLOT, HTAB, IF THEN, IF GOSUB, IF GOTO, INCR, INKEY$, **INP, INPUT, INPUT#, INPUT$, INSTR, INT, **INVERSE, **KEY, LBOUND, LCASE$, LEFT$, LEN, LET, LINE INPUT, LINE INPUT#, LINPUT, LINPUT#, LOCATE, LOF, LOG, LOOP, LOOP UNTIL, LOOP WHILE, LSET, LTRIM$, MID$, MKD$, MKDMBF$, MKI$, MKL$, MKS$, MKSMBF$, NEXT, **NORMAL, OCT$, ON ERROR, ON GOSUB, ON GOTO, **ON KEY, **ON TIMER, OPEN, OPTION BASE, **OUT, **PAINT, **PALETTE, **PCOPY, **PEEK, **PLAY, PLOT, **POINT, **POKE, POS, PRESET, PRINT, PRINT#, PRINT USING, **PR#, PSET, PUT, PUT#, RANDOMIZE, READ, REDIM, REM, RESET, RESTORE, RESUME, RETURN, RIGHT$, RND, RPT$, RSET, RTRIM$, **RUN, SCREEN, SEEK#, SEG$, SELECT, SGN, SIN, SLEEP, **SOUND, SPACE$, SPC, SQR, STOP, STR$, **STRIG, STRING$, **SUB, SUBEND, SUBEXIT, SWAP, SYSTEM, TAB, TAN, TEXT, TIME$, TIMER, **TYPE, UBOUND, UCASE$, VAL, VTAB, WEND, WHILE, WRITE, WRITE#

Operation method

The interpreter reads the lines of the source file into an array of strings. There is no internal representation of the program. The interpreter uses several approaches to support various BASIC dialects.

General

There is no limit for the length of: A line, a string, a variable name or a line number.
Line numbers can contain a decimal point and the line number 0 is allowed.
Lines without line number are allowed.
The sequence ' _' (space and underscore) at the end of a line indicates that the line continues in the next line.
The operators <=, >= and <> can also be written as =<, => and >< .
Hexadecimal numbers can be introduced with '&H' or '&h' and octal numbers with '&O' or '&o'.
The BASIC program can contain garbage. As long as the garbage is not executed, it does not hurt.
It is not necessary to declare arrays with a 'DIM' statement.
A 'DIM' statement initializes arrays such that 'LBOUND' and 'UBOUND' work.
Array subscripts can be written with parenthesis (E.g.: 'A(10)') or brackets (E.g.: 'A[10]').
In 'PRINT' statements it is possible to omit the ';'.
In 'PRINT' statements it is allowed that 'USING' clauses come later in the parameter list. E.g. '100 PRINT"The amount is " USING "##.##";XC'
Some keywords such as 'DO', 'GO', 'DELAY', 'INCR' and 'DECR' can be used as variables. E.g.: 'DO=5'
Labels and variables can have the same name. A statement like 'A:IF B=0 THEN A = 5' does not introduce an infinite loop.
When a file is opened (with 'OPEN', 'CHAIN' or 'INCLUDE') the file name is searched with a case insensitive search.
'REM' can not only be used as statement, but also at places where ' is allowed.
The 'END' statement is allowed to appear in the middle of a program and its execution stops the program (It works just like a 'STOP' statement).
In a BASIC source file control-Z is interpreted as end of file.

Spacing

Bas7 supports the spacing rules used by old BASIC dialects. This rules can be quite different to the ones used is used in newer BASIC dialects:

Line numbers can be written adjacent to the rest of the line. E.g.: '50GOSUB 500'
Keywords can be written adjacent to numbers. E.g.: 'IF I=0THEN 120ELSE 150'
Strings and parenthesis can be written adjacent to keywords. E.g.: 'IF"ASD"=MID$(A$,I,3)THEN'
If a statement is starting with the letters of a keyword and cannot be recognized as 'LET' statement it is handled as if a space is inserted after the keyword. E.g.: 'GOTO250' is equivalent to 'GOTO 250' and '100 REMARKABLY GOOD' is a comment line.
If a certain keyword like 'THEN' or 'TO' is expected and the current symbol starts with the letters of this keyword a space is silently inserted after the keyword. E.g.: 'IF I=5 THENI=2' is interpreted as 'IF I=5 THEN I=2'.
If a 'LET' statement starts with the letters 'IF' and the statement is followed by the letters 'THEN' it is interpreted as 'IF' statement instead. E.g.: 'IFI3=5*J THEN 100' is interpreted as 'IF I3=5*J THEN 100'
If a 'LET' statement starts with the letters 'FOR' and the statement is followed by the letters 'TO' it is interpreted as 'FOR' statement instead. E.g.: 'FORJ1=3*I TO 7*I' is interpreted as 'FOR J1=3*I TO 7*I'
In a 'FIELD' statement it is allowed that the keyword 'AS' is directly followed by a variable without an intermediate space. E.g. '100 FIELD#1,128ASDX$'
Data statements which start with a hex or oct number without a space as in '500 DATA&Habcd' are recognized correctly.

Old BASIC dialects offer the possibility to add whitespace at places where modern BASIC dialects forbid them:

Instead of 'GOTO' it is possible to write 'GO TO'.
Operators can be written with two symbols. E.g.: < = and > < instead of <= and >< .
Functions defined with 'DEF FN*' can be called also if there is a space between 'FN' and the rest of the name. E.g. After the line '100 DEF FNB(C)=-C' the function 'FNB' can be called with '110 A=FN B(35)'.

Literals

Bas7 supports several kinds of literals:

Integer literal: A sequence of digits.
Float literal: A sequence of digits that contains one decimal point. An optional exponent may follow. If an exponent is present the decimal point may be omitted. The exponent is introduced with 'E' or 'e' followed by an optional sign ('+' or '-') and a sequence of digits.
Double precision literal: A float literal where 'D' or 'd' is used to introduce the exponent.
Hex literal: An introducing '&H' or '&h' followed by hex digits.
Octal literal: An introducing '&O' or '&o' followed by octal digits.
String literal: A sequence of characters enclosed in double quotation marks. Quotation marks within the string literal are represented with two consecutive quotation marks.

Numeric literals can uses suffixes like '%', '!', '#' and '&'.

DATA Statements

It is not necessary to put double quotation marks around string constants in 'DATA' statements, unless they contain commas, colons, or significant leading or trailing spaces.
Commas at the end of a 'DATA' line are 'READ' as an empty string.
Empty 'DATA' fields can be read as 0.0.

FOR ... NEXT Statements

In modern BASIC dialects every 'FOR' statement is grouped with exactly one 'NEXT' statement at compile time. There are also strict compile time rules how 'FOR ... NEXT' loops can nest. In old BASIC dialects there are no compile time restrictions and corresponding 'FOR' and 'NEXT' statements are determined at runtime. Bas7 spares no effort to support both older and newer style 'FOR' loops at the same time:

When executing a 'FOR' statement the matching 'NEXT' statement is determined at runtime. If a 'FOR' loop is not entered a statically matching 'NEXT' statement is searched. If a 'FOR' loop is entered the statements following the 'FOR' statement are executed until a corresponding 'NEXT' statement is encountered.
A corresponding 'NEXT' statement can be located inside another statement (e.g.: 'IF' or 'DO') and even before the 'FOR' statement.
A 'FOR' statement can use several corresponding 'NEXT' statements. E.g.: 'FOR I=1 TO 9:IF A(I)=3 THEN N=1:NEXT:ELSE:NEXT'
A 'NEXT' statement can be shared by several 'FOR' loops.
A 'NEXT' statement with a variable like 'NEXT I' is responsible for any 'FOR' loop which uses the variable (e.g.: 'FOR I').
A 'NEXT' statement with a list of variables like 'NEXT X,Y,Z' is responsible for 'FOR' loops which use one of these variables. It is not necessary that the variables in the 'NEXT' statement are ordered. E.g.: 'FOR A=1 TO 5:FOR B=1 TO 5:FOR C=1 TO 5:NEXT A,C,B'
If the 'NEXT I,J,K' statement causes the end of a 'FOR J' loop the interpreter looks if the next active 'FOR' loop uses a remaining variable ('I,K'). In this case the next active 'FOR' loop is processed also. This processing continues until a 'FOR' loop is not left or no matching 'FOR' loop is found.
A 'NEXT' statement without a variable is responsible for the innermost active 'FOR' loop. If a 'NEXT' statement without a variable causes the end of a 'FOR' loop the execution always continues with the next statement (there is no search for another active 'FOR' loop).
A 'NEXT' statement with a variable like 'NEXT A' causes inner 'FOR' loops with other variables like 'FOR I' to be left automatically. An example using this feature is 'FOR A=B TO C:FOR D=E TO F:IF G(D) THEN NEXT ELSE NEXT A'.
Unfinished 'FOR', 'WHILE' and 'DO' loops in a subprogram are left when the 'RETURN', 'END SUB' or 'EXIT SUB' statement is executed. Therefore statements like 'FOR A=B TO C:IF D(A) THEN NEXT:RETURN ELSE RETURN' work.
If a 'NEXT' statement decides to leave a 'FOR' loop the loop variable keeps the last value. This means that after 'FOR N=1 TO 8:NEXT' the variable 'N' has the value '8'.
A warning is written to the log file if a variable got its value from a 'FOR' loop.

GOTO and GOSUB

A 'GOTO' to a non-existing line is recognized and the next existing line is used instead.
Computed gotos can be written in two forms. As 'ON ... GOTO labels' and as 'GOTO ... OF labels'.
Computed gosubs can be written in two forms. As 'ON ... GOSUB labels' and as 'GOSUB ... OF labels'.
A 'GOTO' into a 'DO' loop is allowed.

IF ... THEN Statements

Bas7 supports two versions of the 'IF' statement. The older one-line 'IF' statement and the newer block-structured 'IF' statement. In a block-structured 'IF' statement the keyword 'THEN' is at the end of a line or it is followed by a comment. In a one-line 'IF' statement something else such as a line number, label or statement follows the keyword 'THEN'. Besides the features above there are others things that support 'THEN' statements in old BASIC dialects:

A ':' after a 'THEN' is silently ignored. E.g.: 'IF A$="Y" THEN : OK=1' is executed as 'IF A$="Y" THEN OK=1'
A ':' between label/line number and 'ELSE' is silently ignored. E.g.: 'IF A=13 THEN 340 : ELSE CLS' is executed as 'IF A=13 THEN 340 ELSE CLS'
Statements like 'IF A=0 THEN 100:PRINT' are executed as 'IF A=0 THEN 100 ELSE PRINT'.
An 'ELSE' can directly follow a 'THEN'. E.g.: 'IF C=1 THEN ELSE GOTO 230'
Instead of 'THEN' the keyword 'GOTO' can be used without changing the meaning. E.g.: 'IF D=1 GOTO 240'
Instead of 'THEN' the keyword 'GOSUB' can be used. E.g.: 'IF E=1 GOSUB 250' is executed as 'IF E=1 THEN GOSUB 250'

OPEN Statements

Bas7 supports several versions of 'OPEN'

'OPEN filename [FOR mode1] [ACCESS atype] [ltype] AS [#] filenum [LEN=reclen]'
'OPEN mode2, [#] filenum, filename [,reclen]'
'OPEN #filenum:filename [,organization] [,filetype] [,mode3] [,recordtype]'

Where

filename is a string literal or expression.
filenum is a numeric literal or expression which is rounded to an integer.
mode1 is one of INPUT, OUTPUT, APPEND, RANDOM or BINARY
mode2 is one of "I", "O", "A", "R" or "B"
mode3 is one of INPUT, OUTPUT, UPDATE or APPEND
atype is one of READ, WRITE or READ WRITE
atype is one of SHARED, LOCK READ, LOCK WRITE or LOCK READ WRITE
organization is either SEQUENTIAL or RELATIVE
filetype is either DISPLAY or INTERNAL
recordtype is either VARIABLE or FIXED

Log file

The following errors are written to the log file:

VARIABLE % GOT VALUE % FROM FOR LOOP
% EXPECTED - FOUND %.
% OR % EXPECTED - FOUND %.
%, % OR % EXPECTED - FOUND %.
LABEL % DOES NOT EXIST - USE % INSTEAD
LABEL % DOES NOT EXIST
% - SOME FOR LOOPS WERE NOT LEFT
% - SOME WHILE LOOPS WERE NOT LEFT
% - SOME DO LOOPS WERE NOT LEFT
CANNOT RESUME NEXT
CANNOT RESUME 0
OUT OF DATA
NUMBER EXPECTED FOR INPUT OF % FOUND %.
EXPRESSION EXPECTED - FOUND END OF LINE.
FILE #% NOT OPEN IN INPUT$.
INPUT$ WITH NEGATIVE NUMBER %.
MKDMBF$(%) FAILED
MKSMBF$(%) FAILED
RPT$(%, %) - REPEAT COUNT NEGATIVE
REPEAT COUNT % NEGATIVE IN SPACE$.
REPEAT COUNT % NEGATIVE IN STRING$.
UNEXPECTED SYMBOL %.
REPEAT COUNT % NEGATIVE IN STRING MULTIPLICATION.
ASC("") - ILLEGAL FUNCTION CALL
CVD(%) IS ILLEGAL.
CVDMBF(%) IS ILLEGAL.
CVI(%) IS ILLEGAL.
CVL(%) IS ILLEGAL.
CVS(%) IS ILLEGAL.
CVSMBF(%) IS ILLEGAL.
FILE #% NOT OPEN IN EOF.
INSTR(%, %, %) - ILLEGAL FUNCTION CALL
FILE #% NOT OPEN IN LOF.
LOG(%) - ILLEGAL FUNCTION CALL
SQR(%) - ILLEGAL FUNCTION CALL
ERROR IN PARSE NUMBER %.
DIVISION BY ZERO (% / %)
DIVISION BY ZERO (% \ %)
DIVISION BY ZERO (% MOD %)
COMPARISON EXPECTED - FOUND %.
NO CORRESPONDING "NEXT" OR "NEXT %" FOUND FOR "FOR %"
ELSE NOT AT BEGINNING OF LINE
BLOCK STARTS DIRECTLY AFTER ELSE
BLOCK STARTS DIRECTLY AFTER THEN
GOTO MULTIPLE DEFINED LABEL %.
UNDEFINED LABEL % AFTER "OF".
GOSUB TO MULTIPLE DEFINED LABEL %.
TYPE MISMATCH - LET %=%
"=" EXPECTED AFTER % - FOUND %.
VARIABLE EXPECTED - FOUND %.
MID$(%, %) - ILLEGAL FUNCTION CALL
MID$(%, %, %) - ILLEGAL FUNCTION CALL
STRING VARIABLE EXPECTED - FOUND %
"NEXT %" EXPECTED - FOUND "NEXT %"
UNDEFINED LABEL % AFTER "GOTO".
UNDEFINED LABEL % AFTER "GOSUB".
ELSE - MISSING "END IF".
NEXT % - NO MATCHING FOR FOUND
NEXT % WITHOUT FOR
ON ERROR GOTO NEEDS A LABEL NOT %.
UNDEFINED LABEL % AFTER "ON % %".
NO CORRESPONDING "LOOP" FOUND FOR "DO WHILE"
NO CORRESPONDING "LOOP" FOUND FOR "DO UNTIL"
LOOP - "DO" LOOP ENTERED BY A GOTO
LOOP - NO STATICALLY CORRESPONDING "DO" STATEMENT FOUND
ILLEGAL - "DO % ... LOOP WHILE"
UNEXPECTED "LOOP WHILE"
ILLEGAL - "DO % .. LOOP UNTIL"
UNEXPECTED "LOOP UNTIL"
"CASE" EXPECTED AFTER "SELECT"
'\' - FOUND %.
STRING EXPECTED - FOUND %.
IGNORE %
BAD FILE NUMBER #% IN PRINT.
BAD FILE NUMBER #% IN WRITE.
NUMBER EXPECTED IN READ FOUND % IN DATA LINE %.
FOUND % AFTER % IN DATA LINE %.
NUMBER EXPECTED FOR INPUT OF % FOUND %.
BAD FILE NUMBER #% IN INPUT.
VARIABLE OR STRING EXPECTED - FOUND %.
STRING VARIABLE EXPECTED IN LINE INPUT - FOUND %.
BAD FILE NUMBER #% IN LINE INPUT.
STRING EXPECTED IN LINE INPUT - FOUND %.
STRING VARIABLE EXPECTED IN LINPUT - FOUND %.
BAD FILE NUMBER #% IN LINPUT.
STRING EXPECTED IN LINPUT - FOUND %.
ILLEGAL - OPEN FOR %
ILLEGAL - OPEN %
FILE NOT FOUND %
PUT #% FILE HAS NO RECORD LENGTH SPECIFIED - USE THE FIELD SIZE: %
PUT #% FILE HAS NO RECORD LENGTH SPECIFIED - USE THE SIZE OF THE VARIABLE: %
PUT #% FILE HAS NO RECORD LENGTH SPECIFIED - POSITION IGNORED
PUT #% WITH A RECORD NUMBER OF %
PUT #% - NO STRING VARIABLE PRESENT
BAD FILE NUMBER #% IN PUT.
GET #% FILE HAS NO RECORD LENGTH SPECIFIED - USE THE FIELD SIZE: %
GET #% FILE HAS NO RECORD LENGTH SPECIFIED - USE THE SIZE OF THE VARIABLE: %
GET #% FILE HAS NO RECORD LENGTH SPECIFIED - POSITION IGNORED
GET #% WITH A RECORD NUMBER OF %
GET #% - NO STRING VARIABLE PRESENT
BAD FILE NUMBER #% IN GET.
BAD FILE NUMBER #% IN SEEK.
ILLEGAL DEFDBL %-%
ILLEGAL DEFINT %-%
ILLEGAL DEFLNG %-%
ILLEGAL DEFSNG %-%
ILLEGAL DEFSTR %-%
ILLEGAL DEFDBL %
ILLEGAL DEFINT %
ILLEGAL DEFLNG %
ILLEGAL DEFSNG %
ILLEGAL DEFSTR %
CANNOT GET IMAGE FOR MODE: %
ILLEGAL SCREEN NUMBER: %
CANNOT LOAD IMAGE VARIABLE FROM ARRAY %
UNDEFINED IMAGE VARIABLE %
GET (%, %) - (%, %) = GET (LOWER RIGHT) - (UPPER LEFT)
GET (%, %) - (%, %) = GET (UPPER RIGHT) - (LOWER LEFT)
GET (%, %) - (%, %) = GET (LOWER LEFT) - (UPPER RIGHT)
COLON EXPECTED AFTER LABEL % - FOUND %.
CALL DECLARED BUT UNDEFINED SUB %
CALL UNDEFINED SUB %.
NO CORRESPONDING "END SELECT" FOUND
CHAIN % - FILE NOT FOUND.
STRING EXPECTED FOR CHAIN - FOUND %.
ILLEGAL DECLARE %
ELSEIF - MISSING "END IF".
END SUB - RETURN WITHOUT CALL.
END FUNCTION - RETURN WITHOUT CALL.
UNEXPECTED SYMBOL AFTER END %
ERROR % WITHOUT ON ERROR HANDLER.
NO CORRESPONDING "NEXT" OR "NEXT %" FOUND FOR "EXIT FOR"
NO CORRESPONDING "LOOP" FOUND FOR "EXIT DO"
NO "END SELECT" FOUND
EXIT SUB - RETURN WITHOUT CALL.
EXIT FUNCTION - RETURN WITHOUT CALL.
ILLEGAL STATEMENT "EXIT %"
STRING VARIABLE EXPECTED AS FIELD - FOUND %.
UNEXPECTED SYMBOL "GO".
LOAD % - FILE NOT FOUND.
STRING EXPECTED FOR LOAD - FOUND %.
"=" EXPECTED AFTER "LSET %" - FOUND %.
STRING VARIABLE EXPECTED AFTER LSET - FOUND %.
"=" EXPECTED AFTER "PR" - FOUND %.
RESUME NEXT - NOT IN ERROR HANDLER.
RESUME % - NOT IN ERROR HANDLER.
RESUME 0 - NOT IN ERROR HANDLER.
RESUME % - UNDEFINED RESUME.
RETURN WITHOUT GOSUB.
"=" EXPECTED AFTER "RSET %" - FOUND %.
STRING VARIABLE EXPECTED AFTER RSET - FOUND %.
RUN % - FILE NOT FOUND.
NUMERIC VARIABLE EXPECTED - FOUND %.
SUBEND - RETURN WITHOUT CALL.
SUBEXIT - RETURN WITHOUT CALL.
WEND WITHOUT WHILE.
WHILE WITHOUT WEND.
UNEXPECTED ":" - IGNORED.
DO - NO STATICALLY CORRESPONDING "LOOP" STATEMENT FOUND
LABEL % USED BUT DEFINED MULTIPLE TIMES.
LABEL % USED BUT NOT DEFINED.
LINE NUMBER % ALREADY DEFINED AS %(%)
INCLUDE FILE % NOT FOUND.
SUB % ALREADY DEFINED AS %(%)
FUNCTION % ALREADY DEFINED AS %(%)

Bas7 interpreter starting info

Bas7 interpreter executing hamurabi

Bas7 interpreter executing startrek