Andrew Kesterson
631c70ce7d
A BASIC TYPE and a host C struct are the same thing seen from two sides, so both
go in one type table and everything the language already does with a structure
works across the boundary with no second set of rules. The host describes its
struct once as a table of field descriptors and binds an instance:
akbasic_host_bind(&SCRIPT, "FOE@", "ENEMY", &GOBLIN);
after which `FOE@.HP# = FOE@.HP# - 10` decrements GOBLIN.hp in place, with no
marshalling step the host has to remember to run.
The sharing is done with shadow slots: a binding takes a run from the same value
pool a DIMmed record uses, a field read refreshes its slot from host memory
first, and a write converts back and stores. So the script always sees current
values and its writes always land, while the rest of the interpreter goes on
seeing one storage model instead of two.
AKBASIC_HOST_FIELD takes the offset and the width from the same member, which is
the only reason it is a macro: writing offsetof and sizeof out by hand is two
chances to name the wrong member and no way to notice. A field name's suffix
must agree with the C type it describes, refused at registration -- a host
writing "HP%" over an int32_t has said two different things about one field and
the script would believe the suffix.
Conversion refuses rather than truncates. 200 into an int8_t, 70000 into an
int16_t, -1 into a uint8_t and thirteen characters into a char[8] are each an
error naming the field, because a silent wrap is found three frames later in
code that did nothing wrong. Each width is tested separately, since a range
check is exactly the thing that is right for int32_t and wrong for int8_t when
only one of them is covered.
The language's own distinction turns out to be the one a host needs, so there is
one API rather than two: assignment copies and gives a script a private
snapshot, POINT shares and lets it change the game, and which one happened is
visible in the listing.
Two things the work required. The prescan runs again on every RUN and used to
wipe the whole type table, unregistering the host's types the first time a
script ran; it now keeps what the host registered and drops only what the script
declared. And akbasic_runtime_start() did not rewind, which cost nothing while a
host started a script once and cost everything to a host running one per enemy
-- the second start began past the end and silently did nothing.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
akbasic
A BASIC interpreter written in C, styled after Commodore BASIC 7.0
and the Dartmouth BASIC of 1964. It runs a
.bas file, it gives you a prompt, and — the point of the exercise — it links into a C program
as a scripting engine.
It is a rewrite of basicinterpreter, a Go
implementation that started from the Java Lox instructions in
craftinginterpreters.com and then struck off on its own. That
project is deprecated. It is vendored here as the behavioural spec to read when a question about
semantics comes up, and its acceptance corpus is checked in at
tests/reference/ and runs on every build — so nothing about
building or testing this project needs it.
Quickstart
git submodule update --init --recursive
cmake -S . -B build
cmake --build build --parallel
ctest --test-dir build --output-on-failure
./build/basic # the REPL
./build/basic tests/reference/language/functions.bas # run a program
10 FOR I# = 1 TO 3
20 PRINT "HELLO " + I#
30 NEXT I#
HELLO 1
HELLO 2
HELLO 3
Two things in that program are not Commodore BASIC and will catch you out immediately: variables
carry a type suffix (I# is an integer), and + concatenates a string with a number.
Chapter 3 explains both; Chapter 13 is the
whole list of what differs from a C128.
Graphics, sound and sprites need the SDL build, which is off by default because the interpreter and its entire test suite build on a machine with no SDL installed at all:
cmake -S . -B build-akgl -DAKBASIC_WITH_AKGL=ON
cmake --build build-akgl --parallel
That basic is a different program: it opens a window, draws BASIC output into it in the
Commodore font, and still puts every byte on stdout.
Why rewrite it in C?
Three reasons, in the order they matter.
The interpreter is meant to end up inside libakgl as a scripting engine for game authors, and libakgl is C. Embedding a Go runtime in a C game is not a thing anybody should do to themselves.
The Go version was already written against static pools and explicit state structs — a fixed source table, a fixed variable pool, a 32-leaf ceiling per line — so it ports across almost directly. It reads like C that happens to be spelled in Go.
And the port is a good excuse to find out what the original actually does, as opposed to what it looks like it does. It found five defects nobody knew about.
Design philosophy
A game engine cannot tolerate a scripting language that surprises it. Five rules follow from that, and between them they explain most of what looks unusual in this interpreter:
- Nothing in the library terminates the process. No
exit(), noabort(), nopanic. Errors come back asakerr_ErrorContext *for the host to handle.FINISH_NORETURNappears only in amain(). - Nothing calls
malloc. Every object comes from a fixed pool insideakbasic_Runtime. Exhausting one is a diagnosable error, not a crash and not a slow leak. - No file-scope mutable state. Interpreter state lives in an
akbasic_Runtimeyou own. Two of them in one process do not interfere. - The host owns the loop.
akbasic_runtime_run(rt, n)executes at mostnsteps and returns. A script containing10 GOTO 10costs younsteps per frame and nothing else. - Hardware is a record of function pointers. Graphics, audio, input and sprites attach as
backends, and any of them may be
NULL— that is how a host withholds a capability, and how a host that renders some other way never links libakgl at all.
Nothing is silently ignored, either. A verb that needs a device it was not given, or a capability nothing underneath can supply, refuses by name and says why.
Two ways to use it
As a program. basic is a REPL and a script runner, and the standalone driver owns the
things a library has no business owning: argv, QUIT, and the window in the SDL build.
The guide is written for this reader.
As a library. A host links akbasic::akbasic, hands the interpreter a script, and steps it a
frame at a time:
add_subdirectory(deps/akbasic EXCLUDE_FROM_ALL)
target_link_libraries(YOUR_GAME PRIVATE akbasic::akbasic)
Host and script exchange variables through the same pool the script itself uses — no marshalling
layer and no copy. PRINT goes through an akbasic_TextSink the host supplies, so a game draws
BASIC output into its own text layer. examples/embed.c and
examples/hostvars.c are complete and runnable, and both are built and
run by every build, so they cannot rot. Chapter 10 walks through the API.
What state it is in
Everything the Go version does, and by now a good deal more. All 41 .bas files of the
reference's corpus produce the expected output, including error messages, each as a separate
CTest case so a failure names the file.
What is still missing, what is refused deliberately, and the eleven defects inherited from the Go
version are catalogued in TODO.md and summarised for a BASIC programmer in
Chapter 13.
Where everything else lives
docs/ |
The guide: fourteen chapters, the language then each hardware area then a reference section for every verb and function, Chapter 14 on the interpreter's own architecture, and Chapter 15 listing every error code |
MAINTENANCE.md |
For contributors and maintainers: the documentation-example harness, the three test lists, mutation testing, error-code allocation, style |
TODO.md |
Outstanding defects, with file, line and consequence |
tests/reference/README.md |
Where the golden corpus came from, and the rule for changing it |
API documentation builds with doxygen Doxyfile, into build/docs/html.
Dependencies
Everything is a submodule; git submodule update --init --recursive gets all of it. There is
nothing to install first.
- libakerror 2.0.1 — TRY/CATCH-style error contexts. Every function that can fail returns one. 2.0.0 made it thread safe and broke the ABI; anything built against a 1.x header must be rebuilt rather than relinked.
- libakstdlib 0.2.0 — libc wrappers that
report through
libakerror. String-to-number conversion goes straight to it, which is whyVAL("garbage")is an error rather than a silent0. - libakgl 0.5.0 — optional, only for
-DAKBASIC_WITH_AKGL=ON. Pulls in SDL3. Its soname carriesMAJOR.MINORwhile the major is 0, so rebuild rather than relink. - basicinterpret — the Go original. Not linked, not built, and safe to omit.