*[simple.vm](#simplevm)

*[Compilation](#compilation)

*[Implementation Notes](#implementation-notes)

*[Embedding](#embedding)

*[Instructions](#instructions)

*[Simple Example](#simple-example)

*[Fuzz Testing](#fuzz-testing)

*[See Also](#see-also)

* Git Repository:

simple.vm

This repository contains the implementation for a simple virtual-machine, along with a driver which will read a program from a file and execute it via that virtual machine.

This repository contains the implementation for a__simple__ virtual-machine, along with a driver which will read a program from a file and execute it via that virtual machine.

In addition to the virtual machine interpreter you'll also find:

This particular virtual machine is register-based, having ten registers which can be used to store strings or integer values.

Compilation

Because the compiler and decompiler are written in Perl they need no special

treatment.

The interpretter, written in C, can be built like so:

C intepreter:

This will generate`simple-vm` and`embedded` from the contents of[src/](src/).

Implementation Notes

Implementing a basic virtual machine, like this one, is a pretty well-understood problem:

Embedding

This virtual machine is designed primarily as a learning experience, but it is built with the idea of embedding in mind.

Instructions

There are several instruction-types implemented:

Simple Example

The following program will just endlessly output a string:

There are more examples stored beneath the`examples/` subdirectory in this repository. The file[examples/quine.in](examples/quine.in) provides a good example of various features - it outputs its own opcodes.

Fuzz Testing

If you wish to fuzz-test with[afl](http://lcamtuf.coredump.cx/afl/) you should find that pretty straight-forward:

We set the environmental variable`FUZZ` to contain`1` solely to disable the use of the`system()` function. Which might accidentally remove your home-directory, format your drive, or[send me a donation](https://steve.fi/donate/)!

A golang port of the virtual-machine compiler and interpreter is available from the following repository:

In addition to that you can find a_real_ virtual-machine inside the embedded scripting engine I wrote, also for golang. In that case a scripting language is parsed and converted into a series of bytecode instructions, which are executed by a virtual machine. Similar to this project, but the bytecode operations are more complex and high-level:

If you're interested in compilers, and interpreters, generally you might enjoy these other projects too:

* A simple BASIC interpreter

* A[brainfuck](https://en.wikipedia.org/wiki/Brainfuck) compiler

* A simple compiler for mathematical expressions.

Steve