
T3X – a minimal procedural language - nils-m-holm
http://t3x.org/t3x/
======
bluetomcat
I have a very similar project (not a compiler but an interpreter for a small,
integer-only imperative language): [https://github.com/bbu/simple-
interpreter](https://github.com/bbu/simple-interpreter)

Unlike this recursive-descent parser, my minimalistic language uses a table-
driven shift-reduce parser which is entirely contained in the C code. Both the
lexer and the parser can be extended very easily in order to accommodate new
tokens and new syntactic forms.

~~~
nils-m-holm
T3X9 also uses a table-driven operator-precedence (LR) parser for most binary
operators.

~~~
bluetomcat
Kudos for the bootstrapping ability and for the highly skillfully made ELF and
code generation. I wouldn't be able to do that :-)

~~~
nils-m-holm
Thanks! Decades of experience! :)

~~~
i336_
What might you recommend to someone who wants to to learn more about these
subjects?

For example,
[http://www.muppetlabs.com/~breadbox/software/tiny/teensy.htm...](http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html)
is extremely interesting, but a lot of it is over my head.

I guess at the end of the day there's no real alternative to "just dive into
the source code for a while" with these sorts of things - hence the importance
of having "decades of experience" under your belt - but I'm curious if there's
anywhere in particular that you might recommend as a startpoint.

~~~
nils-m-holm
Yes, examples of minimal ELF files are good starting points for getting the
back end part up and running. I'm not sure that reading real-life code will
get you very far, because it often deals with lots of edge cases and attempts
to be efficient and generate clever code. However, there are compilers that
have been made as educational tools or with simplicity as a major design goal.
I would stick to those in the beginning. See my home page
([http://t3x.org](http://t3x.org)) for lots of examples!

Then, books. I'll make a list some day, I promise! ;) From the top of my head:
Wirth's "Compiler Construction", Richard's "BCPL, the Language and its
Compiler", and - shameless plug - "Practical Compiler Construction" by myself.
I have also read the Dragon Book back then - it's good, but too heavy on
theory for a beginner.

~~~
JdeBP
There is also _Practical Compiling With Pascal-S_ by Rees and Robinson (ISBN
9780201184877), which took the same approach as you do, 30 years ago.

~~~
nils-m-holm
Interesting, thanks! Ordered a copy.

------
stcredzero
It's hard to say what a minimal procedural language is. There are ISAs with a
single instruction:
[https://en.wikipedia.org/wiki/One_instruction_set_computer](https://en.wikipedia.org/wiki/One_instruction_set_computer)

This looks like it's a MISC:
[https://en.wikipedia.org/wiki/Minimal_instruction_set_comput...](https://en.wikipedia.org/wiki/Minimal_instruction_set_computer)

I've also invented something like this: NISC. (Or {}ISC) Null Instruction Set
Computer. You can arbitrarily reduce the die size for implementations of this
architecture, as well as scale the clock speed arbitrarily. It also
revolutionizes cooling.

~~~
oddity
I don't think the description as minimal was intended in any formal way. It's
informally minimal in the sense that it features less complexity than more
well known languages like C or Fortran.

A formal notion of a minimal language/machine gets messy anyway and is of
limited utility even in a purely academic context, as far as I know.

~~~
stcredzero
My NISC ISA is minimal in a comedic context.

------
penpapersw
Very cool! I love minimalistic languages.

How is this able to omit basic type information? Is everything just an int?

> _" It is a statement rather than a production tool."_

What's the statement supposed to be?

~~~
nils-m-holm
>How is this able to omit basic type information? Is everything just an int?

Data is untyped and operators are typed. So in X+Y, X and Y are integers, in
X::Y, X is a byte vector and Y is an integer, and in Y[X], X is an integer and
Y is a vector (and the types of its element again depend on the operators
applied to them).

Note that not all combinations of data and operators make sense. E.g.,
"foo"*[1,2,3] is a valid expression, but probably will not deliver any
meaningful result.

I'll leave the interpretation of the statement to you! ;)

------
nickpsecurity
People who want a simple language like old days should check out Edison
language and system. It's like BCPL minimalism meets Wirth's Oberon:

[http://brinch-hansen.net/papers/1981b.pdf](http://brinch-
hansen.net/papers/1981b.pdf)

He did lots of interesting stuff including a race-free language for
concurrency:

[http://brinch-hansen.net/papers/](http://brinch-hansen.net/papers/)

------
b1gtuna
Is the author of T3X reputable? I am about to drop $20 for the ebook, but I
just want to be sure he has good basis on the subject.

~~~
nils-m-holm
It is, of course, a bit of an oxymoron to answer this question myself but,
FWIW, I have been writing compilers since the 1990's, both as a hobby and as a
job.

I have written compilers for lots of different processors and virtual machines
with varying key aspects, like compilation speed, memory footprint, executable
size, etc.

Check out my home page ([http://t3x.org](http://t3x.org)), there compilers for
many different languages, from mainstream to pretty exotic. There are also
excerpts from many of my books and even the full texts of some of the older
ones.

~~~
register
What about your other book "Lightweight Compiler Techniques? Could you put an
excerpt online?

~~~
nils-m-holm
Oh, yes, the homepage needs some reorganization!

For now, you can download the full text of "Lightweight Compiler Techniques"
here: [http://www.bcl.hamilton.ie/~nmh/t3x.org/zzz/lightweight-
comp...](http://www.bcl.hamilton.ie/~nmh/t3x.org/zzz/lightweight-compiler-
techniques.zip)

Enjoy!

------
bmh100
I mean this earnestly (no snark): why should I care about T3X? I know that I'm
missing the obvious reasons.

~~~
bootload
_" why should I care about T3X?"_

If you look at the source code, you might learn something.

~~~
megapatch
That can be said about a lot of code bases.

~~~
bootload
_" can be said about a lot of code bases."_

True, the poster asked specifically about T3X.

------
b1gtuna
Cool, looks like I have something to read this weekend. I am glad their e-book
caters towards people with little comp-sci / compiler design background.

------
sigjuice
Looks cool, but what is FreeBSD-specific about it? Shouldn't a compiler just
be reading and writing files?

~~~
oddity
It generates FreeBSD executables directly.

>The compiler translates from T3X9 directly to FreeBSD-386-ELF. It does not
require any assembler, linker, or other additional programs. I suspect that it
can be ported to other 32-bit ELF Unixes in about half an hour.

~~~
sitkack
WebAssembly port would be fun.

------
megapatch
The Mandelbrot example has implementation problems. The check for a point
being outside the set is implemented totally wrong, even the comment (which is
not even consistent with the code) is wrong.

Not judging the language itself, but that is not really convincing.

~~~
nils-m-holm
For being "totally wrong" it draws a pretty nice Mandelbrot set!

That being said: yes there are problems with the comments. It's code I have
written decades ago and just copy-pasted now. Will fix! Thanks!

