Interpreter on Werner's home on the Web

Fiz: A Tcl-like interpreter

Thu, 14 Jan 2016 00:00:00 +0000

Over the years I’ve found myself looking at Tcl, and wondering what the fuss was about. Then I came across one of John Ousterhout’s articles in the Dr Dobb’s Journal and as I read through it, I was suddenly enlightened. Tcl is actually a very smart little language.

I gladly accepted the challenge of writing my own interpreter for a Tcl-like language, and present the result here as Fiz (a name I just sucked out of my thumb). As it stands, Fiz is probably not very useful for production use, but it has some features that I like:

It is very compact.
It is easy to extend with new functions written in C.
It is easy to embed it in another application.
It can be run interactively. I’ve got a couple of ideas in the pipeline where entering commands from a shell may be very useful.

I must add the disclaimer that Fiz is probably very slow (I say probably because I did not bother to benchmark it). All variables are strings, and performing arithmetic involves doing an atoi() to convert the variable to an integer. It also does a lot of strdup() internally. I’ll add that at the time of this writing (2010) computers are so fast that I’m not bothered by it; there are other interpreters that fill the “fast and embeddable” niche.

I was also found and got inspiration from Salvatore Sanfilippo’s Picol Tcl interpreter. His is very elegant - he got his interpreter down to about 550 lines of code. You may notice that I borrowed some ideas from him. Source Code

Update (2016-01-14): The source code is available on GitHub: https://github.com/wernsey/Fiz (and has actually been for some time).

The code is written in platform independent C, so you should be able to compile it by typing make on the command prompt if you’re using Linux. It also works if you use MinGW on Windows.

My Unstructured Scripting Language

Sat, 29 Jun 2013 00:00:00 +0000

Over the past few weeks, I’ve spent some time updating my little BASIC dialect, which I called Musl (or MUSL, depending on my mood).

The name can mean either My Unstructured Scripting Language or Marginally Useful Scripting Language, also depending on my mood. Musl’s home official page is on this site and I have now set up a repository on GitHub at http://github.com/wernsey/musl.

If I remember correctly, Musl started out in 2009 when after a couple of beers at a work function I joked that I wanted to create a scripting language that had only IFs and GOTOs. The joke started because some of my earliest memories of programming come from writing simple programs in GW-Basic when I was in primary school.

The goal was to see exactly how little I could get away with. The very first version had a recursive descent parser that created an abstract syntax tree and interpreted it from there. Later, I realised (after seeing this BASIC interpreter’s source code) that if you scan the source code for the labels then you don’t even need the AST.

The latest version of Musl scans the input text for labels before interpreting it. It interprets the code with a pointer that runs through the input text and when it encounters a jump (GOTO, GOSUB or RETURN) the pointer is adjusted accordingly. Musl did not have a GOSUB and RETURN originally, but they were easy to add (GOSUB pushes the current value of the pointer to a stack before jumping, and RETURN then pops that value off the stack again).

I’ve been working on a Retro-style game engine lately, for which I thought that having a BASIC interpreter available would be an appropriate homage to the computers and the games we played on them while growing up, hence my renewed interest in Musl.

From the start I’ve written the code in such a way that the interpreter can be embedded within a larger project. It was intended to be a joke: Write something awesome in it, and then take pictures of the horror on my friends’ faces when I showed them the source code.

Don’t worry, though, I plan to give the engine a proper scripting language, probably Lua, and Musl will only be there for the nostalgia.

Musl - An interpreter for a BASIC language

Fri, 06 Apr 2012 00:00:00 +0000

Also known as my Marginally Useful Scripting Language (I still have to pick the name).

Musl started out as a joke: I stumbled across the atariarchives.org website one evening and browsed through their books on programming games in BASIC. And by BASIC, I really mean old-school style BASIC, not this fancy new style structured language.

You know, like this:

10 PRINT "HELLO WORLD"

Anyways, through my twisted sense of humour, I set out to write my own unstructured language. The original intention was to have a language that had only IF and GOTO statements. The joke was going to be to write some awesome application and watch the horror on my friends’ faces when they see the source code.

Out of principle, I decided that it should be an embeddable scripting language; that is to say, you can embed the interpreter into another application and have the other application execute custom scripts.

Here is a sample of what Musl code looks like:

LET a = 1
loop1:
x[a] = a * a
a = a + 1
IF a < 10 THEN GOTO loop1

If you look through the source code, you’ll find musl.c and musl.h that contains the core of the interpreter. The file main.c contains a simple driver program that shows you how to run the interpreter from another application, how to add new functions to the interpreter and how to access variables within the interpreter.

Over time it feature-crept a bit, and now includes these “features”:

Dictionaries (or hashes or whatever you want to call them)
FOR loops
GOSUB and RETURN
Regular expression support. It uses the regcomp() and regexec() functions that are part of POSIX, but if you want to compile it under Windows, Henry Spencer’s regex library compiles quite easily (with MinGW).
You can declare labels instead of using line numbers. Line numbers are supported, but not required.

Although the syntax may seem BASIC-like, Musl does not strive to be compatible with any known BASIC. The following is an example program:

# This is a test program for "IF x THEN FOR..." type
# situations, which actually took some complexity to get right
x = 0

@start: PRINT(X): IF X THEN PRINT("STARTING...")
10 IF X THEN FOR I = 1 TO 10 DO
20 IF I = 4 THEN GOTO lbl
30 PRINT("X is ", X, "; I is ", I)
40 IF I = 7 THEN NEXT
50 IF I > 2 THEN GOSUB 100
@lbl: NEXT

@foo: IF x = 1 THEN END
x = x+1
GOTO start

#### END ####

100 PRINT("in sub")
RETURN

Source Code 🔗

The latest version of Musl is available on GitHub at https://github.com/wernsey/musl.

Compiling 🔗

On Linux you can compile it by just typing

make

at the command prompt.

I use MinGW to compile these things under Windows.

If you don’t have the regular expression library, you can comment out the following lines in Makefile.mingw:

# CFLAGS += -DWITH_REGEX -I/c/libs/regex
# LFLAGS += -L/c/libs/regex -lregex

To compile, just type

make -f Makefile.mingw

in the MinGW shell.