Help-Site Computer Manuals
  Algorithms & Data Structures   Programming Languages   Revision Control
  Cameras   Computers   Displays   Keyboards & Mice   Motherboards   Networking   Printers & Scanners   Storage
  Windows   Linux & Unix   Mac

Perl Module to interpret BASIC

Language::Basic - Perl Module to interpret BASIC


Language::Basic - Perl Module to interpret BASIC


    use Language::Basic;

    my $Program = new Language::Basic::Program;

    $Program->input("program.bas"); # Read lines from a file

    $Program->parse; # Parse the Program

    $Program->implement; # Run the Program

    $Program->output_perl; # output Program as a Perl program

    $Program->line("20 PRINT X"); # add one line to existing Program

Featured scripts:
Runs BASIC programs from the command line.
Term::Readline program. Input one line of BASIC at a time, then run the program.
Outputs a Perl program that does the same thing as the input BASIC program.


This module lets you run any BASIC programs you may have lying around, or may inspire you to write new ones!

The aspects of the language that are supported are described below. Note that I was pretty much aiming for Applesoft BASIC (tm) ca. 1985, not some modern BASIC with real subroutines.

Class Language::Basic::Program

This class handles a whole program. A Program is just a bunch of Lines, each of which has one or more Statements on it. Running the program involves moving through the lines, usually in numerical order, and implementing each line.


Returns the program currently being parsed/implemented/whatever

Sets arg0 to be the Current Program

Returns the LB::line currently being parsed/implemented/whatever

Sets the current line in Program arg0 to be line number arg1

Returns (not surprisingly) the first line number in Program arg0

What line number in Program arg0 are we currently on?

This method reads in a program from a file, whose name is the string arg0. It doesn't do any parsing, except for taking the line number out of the line.

This method takes a line of BASIC (arg1, already chomped), forms a new LB::Line with it, and adds it to the Program (arg0). It doesn't do any parsing, except for taking the line number out of the line.

This method parses the program, which just involves looping over the lines in the program and parsing each line.

This method actually runs the program. That is, it starts on the first line, and implements statements one at a time. It performs the statements on a line in order, and goes from line to line in numerical order, unless a GOTO, NEXT, etc. sends it somewhere else. It stops when it hits an END statement or ``falls off'' the end of the program.

This method erases program stack and moves line pointer to beginning of program

It should be called any time we start going through the program. (Either implement or output_perl.)

Continue Program execution at the first Statement on line number arg1.

Kind of like goto_line, except go to the Statement after Statement arg1. (Or the first statement on the line just after Statement arg1, if it's the last Statement on its line.) E.g., when you RETURN from a GOSUB, you want to return to the GOSUB line but start execution after the GOSUB. Same with FOR.

The following methods are called from LB::Statement parse or implement methods to implement various BASIC commands.

(GOSUB) Call a subroutine, i.e. push the current Statement::Gosub onto the Program's calling stack

(RETURN) Return from a subroutine, i.e., pop the top Statement::Gosub off of the Program's calling stack

(FOR) Store a Statement::For arg1, so that when we get to the corresponding Statement::Next, we know where to go back to

(NEXT) Get the Statement::For corresponding to Statement::Next arg1

(DATA) Add a piece of data to the Program's data storage, to be accessed later.

(READ) Get a piece of data that was stored earlier.

Finally, there are methods for translating a Program to Perl.

This method translates a program to Perl and outputs it. It does so by looping through the Lines of the program in order, and calling output_perl on each one. It also prints some pre- and post- data, such as any subroutines it needs to declare (e.g., subs that imitate BASIC functionality, as well as subs that correspond to BASIC DEF statements).

It attempts to print everything out nicely, with added whitespace et al. to make the code somewhat readable. (Note that all of the subpackages' output_perl methods return strings rather than printing them, so we can handle all of the printing, indenting, etc. here.)

Tells the Program that it needs to use the sub named arg0 (whose definition is in arg1). This is used for outputting a Perl translation of a BASIC program, so that you only write ``sub mid_str {...}'' if MID$ is used in the BASIC program.

Class Language::Basic::Line

This class handles one line of a BASIC program, which has one or more Statements on it.

This class has no implement method. The reason is that sometimes, you'll jump to the middle of a line. (E.g., returning from the GOSUBs in 10 FOR A=1 TO 10: GOSUB 1000: NEXT A)


Returns the Line's line number

Returns the next line number in the Program

Sets the next line number in the Program to be arg1.

This method breaks the line up into Statements (and removes whitespace, except in strings), then parses the Statements in order.

This method simply calls output_perl on each of the Line's Statements in order.


This is a (hopefully current) description of what Language::Basic supports. For each command, I give an example use of that command, and possible a comment or two about it.

Also see the Language::Basic::Syntax manpage, which describes the exact syntax for each statement, expressions, variable names, etc.


DATA 1,2,``HI''. These will be read sequentially by READ statements. Note that currently all string constants must be quoted.

DEF FNA(X)= INT(X + .5).

DIM A(20), B(10,10). Arrays default to size 10 (or actually 11 since they start at zero.)


FOR I = 1 TO 10 STEP 3. STEP defaults to 1 if not given, and may be negative. (For loops are always implemented at least once.)

GOTO 30. Note that GOTO 30+(X*3) is also supported.

GOSUB 10+X. Gosub is just like GOTO, except that when the program gets to a RETURN statement, it will come back to the statement just after the GOSUB.

IF X > Y THEN 30 ELSE X = X + 1. ELSE is not required. In a THEN or ELSE, a lone number means GOTO that number (also known as an implied GOTO).

INPUT A$, B$. Also allowed is INPUT ``FOO''; BAR. This prints ``FOO?'' instead of just ``?'' as the input prompt.

LET X=4. The word ``LET'' isn't required; i.e. X=4 is just like LET X=4.

NEXT I. Increment I by STEP, test against its limit, go back to the FOR statement if it's not over (or under, for a descending loop) its limit.

ON X-3 GOSUB 10,20. This is equivalent to: IF X-3 = 1 THEN GOSUB 10 IF X-3 = 2 THEN GOSUB 20

ON ... GOTO is also allowed.

PRINT FOO; BAR$, 6*BLAH. semicolon means no space (or one space after printing numbers!), comma is like a 14-character tab (or \n past column 56). Print \n after the last expression unless there's a semicolon after it.

READ A, B(I), C$. Reads data from DATA statements into variables

REM WHATEVER. Anything after the REM is ignored (including colons and succeeding statements!)

RETURN. Return to the statement after the last GOSUB.

Intrinsic functions

The following functions are currently supported:

Numeric Functions: INT (like Perl's int), RND (rand), ASC (ord), LEN (length), VAL (turn a string into a number; in Perl you just + 0 :))

RND just calls Perl's rand; you can't seed it or anything.

String functions: CHR$, MID$, STR$

Overall Coding Issues

  • Multiple statements can appear on one line, separated by colons. E.g.: 10 FOR I = 1 TO 10: PRINT I: NEXT I, or 20 FOR A = 1 TO 4: GOSUB 3000: NEXT A. Note that after a THEN, all statements are considered part of the THEN, until a statement starting with ELSE, after which all remaining statements are part of the ELSE. A REM slurps up everything until the end of the line, including colons.

  • Hopefully your code doesn't have many bugs, because there isn't much error checking.

  • Everything except string constants is converted to upper case, so 'a' and 'A' are the same variable. (But note that the string ``Yes'' <> ``YES'', at least for now.)

  • Spaces are (currently) required around various pieces of the program, like THEN, ELSE, GOTO. That is, GOTO20 won't work. This may or may not change in the future.

  • When you use (&LB::Program::input), the lines in the input file must be in numerical order. When using (&LB::Program::line), this rule doesn't apply.


This is an alpha release and likely contains many bugs; these are merely the known ones.

If you use multiple Language::Basic::Program objects in a Perl program, functions and variables can leak over from one to another.

It is possible to get some Perl warnings; for example, if you input a string into a numerical variable and then do something with it.

PRINT and so forth all go to the select-ed output handle; there really ought to be a way to set for a Program the output handle.

There needs to be better and consistent error handling, and a more extensive test suite.


Amir Karger (

David Glasser gave ideas and feedback, hunted down bugs, and sent in a major patch to help the LB guts.


Copyright (c) Amir Karger 2000


This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.


BASIC stands for Beginner's All-purpose Symbolic Instruction Code. Since it was considered pretty hot stuff in the early 80's, it's the first language that I and a lot of folks my age learned, so it holds a special place in my heart. Which is the only reason I spent so many hours writing an interpreter for it long after it was superseded by real interpreted languages that had subroutines and didn't rely quite so much on GOTO.

I originally wrote this interpreter in C, as the final project for my first C programming class in college. Its name at that point was COMPLEX, which stood for ``C-Oriented Major Project which did not use LEX''.

When I learned Perl, I felt like its string handling capabilities would be much better for an interpreter, so eventually I ported and expanded it. (Incidentally, I was right. I had surpassed the original program's functionality in less than a week, and I was able to run wumpus in 2.)

A big goal for the Perl port is to support enough of the language that I can run wumpus, another legacy from my childhood. The interpreter's name could be changed from COMPLEX to ``Perl Eclectic Retro interpreter which did not use Parse::LEX'', or PERPLEX, but I settled for Language::Basic instead.


All of the the Language::Basic::* manpages associated with Language::Basic sub-modules

the Language::Basic::Syntax manpage, which describes the syntax supported by the Language::Basic module

perl(1), wump(6)