This project is to bootstrap a language processor from a hand-written ELF binary.
This is a hobby project and is not intended for any practical use, but constructing a language processor completely from scratch is a lot of fun.
Please try running, reading and playing with the code!
Bootstrapping proceeds as follows:
1. Implement a simple Forth interpreter (really) by handwriting ELF.
2. Grow it into a relatively expressive language through self-extension.
Since writing a program in machine language by hand is a tough work, the first
interpreter is designed to be very simple. Every built-in word is single-letter and the interpreter just repeats that reads a character, looks it up from the dictionary and executes it. Also there is no error checking.
This is the actual code for the first interpreter, which is a 136-byte implementation of the interpreter followed by a built-in dictionary of 888 bytes.
However, at the end, you can write a normal Forth program as follows.
In this way, the interpreter and the language are extended during the execution of the single script.
$ tail bootstrap.fs
next-arg dup argv @ !
included
else
." Welcome to PlanckForth " version type
." [" runtime type ." ]" cr
copyright
." Type 'bye' to exit." cr
s" /dev/tty" included
then
; execute
Various functionalities like compile mode, immediate mode, control-flow structures, literals, variables, constants, file I/O, heap memory, etc. will be available after running bootstrap.fs.
Also, the language and bootstrap.fs are designed to be as environment-independent as possible, so you can implement the runtime in other languages as well.
As an example, I added an implementation of the runtime in C and Python 3.
There is no space for detailed explanation here. So please read the following source code and comments.
Also, there is a commentary article in Japanese here.
I hope you can read it with google translate.
(I will write it in English if I have time. someday.)
Bootstrapping proceeds as follows:
1. Implement a simple Forth interpreter (really) by handwriting ELF. 2. Grow it into a relatively expressive language through self-extension.
Since writing a program in machine language by hand is a tough work, the first interpreter is designed to be very simple. Every built-in word is single-letter and the interpreter just repeats that reads a character, looks it up from the dictionary and executes it. Also there is no error checking.
This is the actual code for the first interpreter, which is a 136-byte implementation of the interpreter followed by a built-in dictionary of 888 bytes.
https://github.com/nineties/planckforth/blob/main/planck.xxd
The first interpreter and language is so esoteric that, for example, the Hello World looks like this.
bootstrap.fs self-extends this. After running bootstrap.fs, the Hello World program can be written like this
At the beginning of bootstrap.fs, you can only use one-letter words, so the code is difficult to read as shown below.
However, at the end, you can write a normal Forth program as follows. In this way, the interpreter and the language are extended during the execution of the single script.
Various functionalities like compile mode, immediate mode, control-flow structures, literals, variables, constants, file I/O, heap memory, etc. will be available after running bootstrap.fs.
Also, the language and bootstrap.fs are designed to be as environment-independent as possible, so you can implement the runtime in other languages as well. As an example, I added an implementation of the runtime in C and Python 3.
There is no space for detailed explanation here. So please read the following source code and comments.
https://github.com/nineties/planckforth/blob/main/bootstrap....
Also, there is a commentary article in Japanese here. I hope you can read it with google translate. (I will write it in English if I have time. someday.)
https://qiita.com/9_ties/items/349b2ed65b7cd8a7d580
Feedbacks and pull requests such as runtime implementations in other languages are very welcome.
Thank you for reading.