/* A sometimes minimal FORTH compiler and tutorial for Linux / i386 systems. -*- asm -*-
By Richard W.M. Jones <rich@annexia.org> http://annexia.org/forth
+ This is PUBLIC DOMAIN (see public domain release statement below).
+ $Id: jonesforth.S,v 1.38 2007-09-28 19:39:21 rich Exp $
gcc -m32 -nostdlib -static -Wl,-Ttext,0 -o jonesforth jonesforth.S
-
+*/
+ .set JONES_VERSION,38
+/*
INTRODUCTION ----------------------------------------------------------------------
FORTH is one of those alien languages which most working programmers regard in the same
over every other element in a list of numbers? You can add it to the language. What
about an operator which pulls in variables directly from a configuration file and makes
them available as FORTH variables? Or how about adding Makefile-like dependencies to
- the language? No problem in FORTH. This concept isn't common in programming languages,
+ the language? No problem in FORTH. How about modifying the FORTH compiler to allow
+ complex inlining strategies -- simple. This concept isn't common in programming languages,
but it has a name (in fact two names): "macros" (by which I mean LISP-style macros, not
the lame C preprocessor) and "domain specific languages" (DSLs).
http://wiki.laptop.org/go/Forth_Lessons
+ http://www.albany.net/~hello/simple.htm
+
Here is another "Why FORTH?" essay: http://www.jwdt.com/~paysan/why-forth.html
+ Discussion and criticism of this FORTH here: http://lambda-the-ultimate.org/node/2452
+
ACKNOWLEDGEMENTS ----------------------------------------------------------------------
This code draws heavily on the design of LINA FORTH (http://home.hccnet.nl/a.w.m.van.der.horst/lina.html)
by Albert van der Horst. Any similarities in the code are probably not accidental.
- Also I used this document (http://ftp.funet.fi/pub/doc/IOCCC/1992/buzzard.2.design) which really
- defies easy explanation.
+ Some parts of this FORTH are also based on this IOCCC entry from 1992:
+ http://ftp.funet.fi/pub/doc/IOCCC/1992/buzzard.2.design.
+ I was very proud when Sean Barrett, the original author of the IOCCC entry, commented in the LtU thread
+ http://lambda-the-ultimate.org/node/2452#comment-36818 about this FORTH.
+
+ And finally I'd like to acknowledge the (possibly forgotten?) authors of ARTIC FORTH because their
+ original program which I still have on original cassette tape kept nagging away at me all these years.
+ http://en.wikipedia.org/wiki/Artic_Software
+
+ PUBLIC DOMAIN ----------------------------------------------------------------------
+
+ I, the copyright holder of this work, hereby release it into the public domain. This applies worldwide.
+
+ In case this is not legally possible, I grant any entity the right to use this work for any purpose,
+ without any conditions, unless such conditions are required by law.
SETTING UP ----------------------------------------------------------------------
assemble and run the code (save this file as 'jonesforth.S') are:
gcc -m32 -nostdlib -static -Wl,-Ttext,0 -o jonesforth jonesforth.S
- ./jonesforth
-
- You will see lots of 'Warning: unterminated string; newline inserted' messages from the
- assembler. That's just because the GNU assembler doesn't have a good syntax for multi-line
- strings (or rather it used to, but the developers removed it!) so I've abused the syntax
- slightly to make things readable. Ignore these warnings.
+ cat jonesforth.f - | ./jonesforth
If you want to run your own FORTH programs you can do:
- ./jonesforth < myprog.f
+ cat jonesforth.f myprog.f | ./jonesforth
If you want to load your own FORTH code and then continue reading user commands, you can do:
- cat myfunctions.f - | ./jonesforth
+ cat jonesforth.f myfunctions.f - | ./jonesforth
ASSEMBLER ----------------------------------------------------------------------
THE DICTIONARY ----------------------------------------------------------------------
- In FORTH as you will know, functions are called "words", as just as in other languages they
+ In FORTH as you will know, functions are called "words", and just as in other languages they
have a name and a definition. Here are two FORTH words:
: DOUBLE DUP + ; \ name is "DOUBLE", definition is "DUP +"
|
LATEST
- You shoud be able to see from this how you might implement functions to find a word in
+ You should be able to see from this how you might implement functions to find a word in
the dictionary (just walk along the dictionary entries starting at LATEST and matching
- the names until you either find a match or hit the NULL pointer at the end of the dictionary),
+ the names until you either find a match or hit the NULL pointer at the end of the dictionary);
and add a word to the dictionary (create a new definition, set its LINK to LATEST, and set
LATEST to point to the new word). We'll see precisely these functions implemented in
assembly code later on.
and so on. How would a function, say 'f' above, be compiled by a standard C compiler?
Probably into assembly code like this. On the right hand side I've written the actual
- 16 bit machine code.
+ i386 machine code.
f:
CALL a E8 08 00 00 00
1C 00 00 00 the CALL prefix.
2C 00 00 00
+ On a 16-bit machine like the ones which originally ran FORTH the savings are even greater - 33%.
+
[Historical note: If the execution model that FORTH uses looks strange from the following
paragraphs, then it was motivated entirely by the need to save memory on early computers.
This code compression isn't so important now when our machines have more memory in their L1
%esi -> 1C 00 00 00
2C 00 00 00
- The all-important x86 instruction is called LODSL (or in Intel manuals, LODSW). It does
+ The all-important i386 instruction is called LODSL (or in Intel manuals, LODSW). It does
two things. Firstly it reads the memory at %esi into the accumulator (%eax). Secondly it
increments %esi by 4 bytes. So after LODSL, the situation now looks like this:
+-----> +------------------+
| codeword -------+
+------------------+ |
- now we're | assembly to <------+
+ now we're | assembly to <-----+
executing | implement + |
this | .. |
function | .. |
| addr of DOUBLE ---------------> +------------------+
+------------------+ %eax -> | addr of DOCOL |
%esi -> | addr of DOUBLE | +------------------+
- +------------------+ | addr of DUP -------------->
+ +------------------+ | addr of DUP |
| addr of EXIT | +------------------+
+------------------+ | etc. |
- First, the call to DOUBLE causes DOCOL (the codeword of DOUBLE). DOCOL does this: It
+ First, the call to DOUBLE calls DOCOL (the codeword of DOUBLE). DOCOL does this: It
pushes the old %esi on the return stack. %eax points to the codeword of DOUBLE, so we
just add 4 on to it to get our new %esi:
| addr of DOUBLE ---------------> +------------------+
top of return +------------------+ %eax -> | addr of DOCOL |
stack points -> | addr of DOUBLE | + 4 = +------------------+
- +------------------+ %esi -> | addr of DUP -------------->
+ +------------------+ %esi -> | addr of DUP |
| addr of EXIT | +------------------+
+------------------+ | etc. |
.bss
/* FORTH return stack. */
-#define RETURN_STACK_SIZE 8192
+ .set RETURN_STACK_SIZE,8192
.align 4096
.space RETURN_STACK_SIZE
return_stack: // Initial top of return stack.
-/* Space for user-defined words. */
-#define USER_DEFS_SIZE 16384
+/* The user definitions area: space for user-defined words and general memory allocations. */
+ .set USER_DEFS_SIZE,65536
.align 4096
user_defs_start:
.space USER_DEFS_SIZE
+/* This is used as a temporary input buffer when reading from files or the terminal. */
+ .set BUFFER_SIZE,4096
+ .align 4096
+buffer:
+_initbufftop:
+ .space BUFFER_SIZE
+buffend:
+currkey:
+ .int buffer
+bufftop:
+ .int _initbufftop
+
/*
BUILT-IN WORDS ----------------------------------------------------------------------
- Remember our dictionary entries (headers). Let's bring those together with the codeword
+ Remember our dictionary entries (headers)? Let's bring those together with the codeword
and data words to see how : DOUBLE DUP + ; really looks in memory.
pointer to previous word
*/
/* Flags - these are discussed later. */
-#define F_IMMED 0x80
-#define F_HIDDEN 0x20
+ .set F_IMMED,0x80
+ .set F_HIDDEN,0x20
+ .set F_LENMASK,0x1f // length mask
// Store the chain of links.
.set link,0
+--|------+---+---+---+---+------------+
| LINK | 3 | D | U | P | code_DUP ---------------------> points to the assembly
+---------+---+---+---+---+------------+ code used to write DUP,
- ^ len codeword which is ended with NEXT.
+ ^ len codeword which ends with NEXT.
|
LINK in next word
push %ecx
NEXT
+ defcode "?DUP",4,,QDUP // duplicate top of stack if non-zero
+ pop %eax
+ test %eax,%eax
+ jz 1f
+ push %eax
+1: push %eax
+ NEXT
+
defcode "1+",2,,INCR
incl (%esp) // increment top of stack
NEXT
NEXT
defcode "4+",2,,INCR4
- addl $4,(%esp) // increment top of stack
+ addl $4,(%esp) // add 4 to top of stack
NEXT
defcode "4-",2,,DECR4
- subl $4,(%esp) // decrement top of stack
+ subl $4,(%esp) // subtract 4 from top of stack
NEXT
defcode "+",1,,ADD
defcode "-",1,,SUB
pop %eax // get top of stack
- subl %eax,(%esp) // and subtract if from next word on stack
+ subl %eax,(%esp) // and subtract it from next word on stack
NEXT
defcode "*",1,,MUL
push %eax // ignore overflow
NEXT
- defcode "/",1,,DIV
- xor %edx,%edx
- pop %ebx
- pop %eax
- idivl %ebx
- push %eax // push quotient
- NEXT
+/*
+ In this FORTH, only /MOD is primitive. Later we will define the / and MOD words in
+ terms of the primitive /MOD. The design of the i386 assembly instruction idiv which
+ leaves both quotient and remainder makes this obvious choice.
+*/
- defcode "MOD",3,,MOD
+ defcode "/MOD",4,,DIVMOD
xor %edx,%edx
pop %ebx
pop %eax
idivl %ebx
push %edx // push remainder
+ push %eax // push quotient
NEXT
defcode "=",1,,EQU // top two words are equal?
1: pushl $0
NEXT
+ defcode "<",1,,LT
+ pop %eax
+ pop %ebx
+ cmp %eax,%ebx
+ jl 1f
+ pushl $0
+ NEXT
+1: pushl $1
+ NEXT
+
+ defcode ">",1,,GT
+ pop %eax
+ pop %ebx
+ cmp %eax,%ebx
+ jg 1f
+ pushl $0
+ NEXT
+1: pushl $1
+ NEXT
+
+ defcode "<=",2,,LE
+ pop %eax
+ pop %ebx
+ cmp %eax,%ebx
+ jle 1f
+ pushl $0
+ NEXT
+1: pushl $1
+ NEXT
+
+ defcode ">=",2,,GE
+ pop %eax
+ pop %ebx
+ cmp %eax,%ebx
+ jge 1f
+ pushl $0
+ NEXT
+1: pushl $1
+ NEXT
+
defcode "0=",2,,ZEQU // top of stack equals 0?
pop %eax
test %eax,%eax
1: pushl $1
NEXT
- defcode "AND",3,,AND
+ defcode "0<>",3,,ZNEQU // top of stack not 0?
+ pop %eax
+ test %eax,%eax
+ jnz 1f
+ pushl $0
+ NEXT
+1: pushl $1
+ NEXT
+
+ defcode "0<",2,,ZLT // comparisons with 0
+ pop %eax
+ test %eax,%eax
+ jl 1f
+ pushl $0
+ NEXT
+1: pushl $1
+ NEXT
+
+ defcode "0>",2,,ZGT
+ pop %eax
+ test %eax,%eax
+ jg 1f
+ pushl $0
+ NEXT
+1: pushl $1
+ NEXT
+
+ defcode "0<=",3,,ZLE
+ pop %eax
+ test %eax,%eax
+ jle 1f
+ pushl $0
+ NEXT
+1: pushl $1
+ NEXT
+
+ defcode "0>=",3,,ZGE
+ pop %eax
+ test %eax,%eax
+ jge 1f
+ pushl $0
+ NEXT
+1: pushl $1
+ NEXT
+
+ defcode "AND",3,,AND // bitwise AND
pop %eax
andl %eax,(%esp)
NEXT
- defcode "OR",2,,OR
+ defcode "OR",2,,OR // bitwise OR
pop %eax
orl %eax,(%esp)
NEXT
- defcode "INVERT",6,,INVERT // this is the FORTH "NOT" function
+ defcode "XOR",3,,XOR // bitwise XOR
+ pop %eax
+ xorl %eax,(%esp)
+ NEXT
+
+ defcode "INVERT",6,,INVERT // this is the FORTH bitwise "NOT" function (cf. NEGATE)
notl (%esp)
NEXT
| addr of EXIT |
+------------------+
- And NEXT just completes the job by, well in this case just by calling DOUBLE again :-)
+ And NEXT just completes the job by, well, in this case just by calling DOUBLE again :-)
LITERALS ----------------------------------------------------------------------
subl %eax,(%ebx) // add it
NEXT
-/* ! and @ (STORE and FETCH) store 32-bit words. It's also useful to be able to read and write bytes.
- * I don't know whether FORTH has these words, so I invented my own, called !b and @b.
- * Byte-oriented operations only work on architectures which permit them (i386 is one of those).
- * UPDATE: writing a byte to the dictionary pointer is called C, in FORTH.
+/*
+ ! and @ (STORE and FETCH) store 32-bit words. It's also useful to be able to read and write bytes
+ so we also define standard words C@ and C!.
+
+ Byte-oriented operations only work on architectures which permit them (i386 is one of those).
*/
- defcode "!b",2,,STOREBYTE
+
+ defcode "C!",2,,STOREBYTE
pop %ebx // address to store at
pop %eax // data to store there
movb %al,(%ebx) // store it
NEXT
- defcode "@b",2,,FETCHBYTE
+ defcode "C@",2,,FETCHBYTE
pop %ebx // address to fetch
xor %eax,%eax
movb (%ebx),%al // fetch it
_Y
_Z
S0 Stores the address of the top of the parameter stack.
- R0 Stores the address of the top of the return stack.
+ BASE The current base for printing and reading numbers.
*/
defvar "STATE",5,,STATE
defvar "_Y",2,,TY
defvar "_Z",2,,TZ
defvar "S0",2,,SZ
- defvar "R0",2,,RZ,return_stack
+ defvar "BASE",4,,BASE,10
+
+/*
+ BUILT-IN CONSTANTS ----------------------------------------------------------------------
+
+ It's also useful to expose a few constants to FORTH. When the word is executed it pushes a
+ constant value on the stack.
+
+ The built-in constants are:
+
+ VERSION Is the current version of this FORTH.
+ R0 The address of the top of the return stack.
+ DOCOL Pointer to DOCOL.
+ F_IMMED The IMMEDIATE flag's actual value.
+ F_HIDDEN The HIDDEN flag's actual value.
+ F_LENMASK The length mask in the flags/len byte.
+*/
+
+ .macro defconst name, namelen, flags=0, label, value
+ defcode \name,\namelen,\flags,\label
+ push $\value
+ NEXT
+ .endm
+
+ defconst "VERSION",7,,VERSION,JONES_VERSION
+ defconst "R0",2,,RZ,return_stack
+ defconst "DOCOL",5,,__DOCOL,DOCOL
+ defconst "F_IMMED",7,,__F_IMMED,F_IMMED
+ defconst "F_HIDDEN",8,,__F_HIDDEN,F_HIDDEN
+ defconst "F_LENMASK",9,,__F_LENMASK,F_LENMASK
/*
RETURN STACK ----------------------------------------------------------------------
and compiling code, we might be reading words to execute, we might be asking for the user
to type their name -- ultimately it all comes in through KEY.
- The implementation of KEY uses an input buffer so a certain size (defined at the end of the
+ The implementation of KEY uses an input buffer of a certain size (defined at the end of the
program). It calls the Linux read(2) system call to fill this buffer and tracks its position
in the buffer using a couple of variables, and if it runs out of input buffer then it refills
it automatically. The other thing that KEY does is if it detects that stdin has closed, it
What it does in detail is that it first skips any blanks (spaces, tabs, newlines and so on).
Then it calls KEY to read characters into an internal buffer until it hits a blank. Then it
calculates the length of the word it read and returns the address and the length as
- two words on the stack (with address at the top).
+ two words on the stack (with the length at the top of stack).
Notice that WORD has a single internal buffer which it overwrites each time (rather like
a static C string). Also notice that WORD's internal buffer is just 32 bytes long and
defcode "WORD",4,,WORD
call _WORD
- push %ecx // push length
push %edi // push base address
+ push %ecx // push length
NEXT
_WORD:
5: .space 32
/*
- . (also called DOT) prints the top of the stack as an integer. In real FORTH implementations
- it should print it in the current base, but this assembler version is simpler and can only
- print in base 10.
-
- Remember that you can override even built-in FORTH words easily, so if you want to write a
- more advanced DOT then you can do so easily at a later point, and probably in FORTH.
-*/
-
- defcode ".",1,,DOT
- pop %eax // Get the number to print into %eax
- call _DOT // Easier to do this recursively ...
- NEXT
-_DOT:
- mov $10,%ecx // Base 10
-1:
- cmp %ecx,%eax
- jb 2f
- xor %edx,%edx // %edx:%eax / %ecx -> quotient %eax, remainder %edx
- idivl %ecx
- pushl %edx
- call _DOT
- popl %eax
- jmp 1b
-2:
- xor %ah,%ah
- aam $10
- cwde
- addl $'0',%eax
- call _EMIT
- ret
-
-/*
- Almost the opposite of DOT (but not quite), SNUMBER parses a numeric string such as one returned
- by WORD and pushes the number on the parameter stack.
+ As well as reading in words we'll need to read in numbers and for that we are using a function
+ called SNUMBER. This parses a numeric string such as one returned by WORD and pushes the
+ number on the parameter stack.
This function does absolutely no error checking, and in particular the length of the string
must be >= 1 bytes, and should contain only digits 0-9. If it doesn't you'll get random results.
So if DOUBLE is defined in the dictionary, then WORD DOUBLE FIND returns the following pointer:
- pointer to this
+ pointer to this
|
|
V
| LINK | 6 | D | O | U | B | L | E | 0 | DOCOL | DUP | + | EXIT |
+---------+---+---+---+---+---+---+---+---+------------+------------+------------+------------+
- See also >CFA which takes a dictionary entry pointer and returns a pointer to the codeword.
+ See also >CFA and >DFA.
FIND doesn't find dictionary entries which are flagged as HIDDEN. See below for why.
*/
defcode "FIND",4,,FIND
- pop %edi // %edi = address
pop %ecx // %ecx = length
+ pop %edi // %edi = address
call _FIND
- push %eax
+ push %eax // %eax = address of dictionary entry (or NULL)
NEXT
_FIND:
// this won't pick the word (the length will appear to be wrong).
xor %eax,%eax
movb 4(%edx),%al // %al = flags+length field
- andb $(F_HIDDEN|0x1f),%al // %al = name length
+ andb $(F_HIDDEN|F_LENMASK),%al // %al = name length
cmpb %cl,%al // Length is the same?
jne 2f
/*
FIND returns the dictionary pointer, but when compiling we need the codeword pointer (recall
- that FORTH definitions are compiled into lists of codeword pointers).
+ that FORTH definitions are compiled into lists of codeword pointers). The standard FORTH
+ word >CFA turns a dictionary pointer into a codeword pointer.
+
+ The example below shows the result of:
- In the example below, WORD DOUBLE FIND >CFA
+ WORD DOUBLE FIND >CFA
FIND returns a pointer to this
| >CFA converts it to a pointer to this
that is not true in most FORTH implementations where they store a back pointer in the definition
(with an obvious memory/complexity cost). The reason they do this is that it is useful to be
able to go backwards (codeword -> dictionary entry) in order to decompile FORTH definitions.
+
+ What does CFA stand for? My best guess is "Code Field Address".
*/
defcode ">CFA",4,,TCFA
add $4,%edi // Skip link pointer.
movb (%edi),%al // Load flags+len into %al.
inc %edi // Skip flags+len byte.
- andb $0x1f,%al // Just the length, not the flags.
+ andb $F_LENMASK,%al // Just the length, not the flags.
add %eax,%edi // Skip the name.
addl $3,%edi // The codeword is 4-byte aligned.
andl $~3,%edi
ret
/*
+ Related to >CFA is >DFA which takes a dictionary entry address as returned by FIND and
+ returns a pointer to the first data field.
+
+ FIND returns a pointer to this
+ | >CFA converts it to a pointer to this
+ | |
+ | | >DFA converts it to a pointer to this
+ | | |
+ V V V
+ +---------+---+---+---+---+---+---+---+---+------------+------------+------------+------------+
+ | LINK | 6 | D | O | U | B | L | E | 0 | DOCOL | DUP | + | EXIT |
+ +---------+---+---+---+---+---+---+---+---+------------+------------+------------+------------+
+
+ (Note to those following the source of FIG-FORTH / ciforth: My >DFA definition is
+ different from theirs, because they have an extra indirection).
+
+ You can see that >DFA is easily defined in FORTH just by adding 4 to the result of >CFA.
+*/
+
+ defword ">DFA",4,,TDFA
+ .int TCFA // >CFA (get code field address)
+ .int INCR4 // 4+ (add 4 to it to get to next word)
+ .int EXIT // EXIT (return from FORTH word)
+
+/*
COMPILING ----------------------------------------------------------------------
Now we'll talk about how FORTH compiles words. Recall that a word definition looks like this:
- : DOUBLE DUP + ;
+ : DOUBLE DUP + ;
and we have to turn this into:
LATEST points here points to codeword of DUP
There are several problems to solve. Where to put the new word? How do we read words? How
- do we define : (COLON) and ; (SEMICOLON)?
+ do we define the words : (COLON) and ; (SEMICOLON)?
FORTH solves this rather elegantly and as you might expect in a very low-level way which
- allows you to change how the compiler works in your own code.
+ allows you to change how the compiler works on your own code.
FORTH has an INTERPRETER function (a true interpreter this time, not DOCOL) which runs in a
loop, reading words (using WORD), looking them up (using FIND), turning them into codeword
- points (using >CFA) and deciding what to do with them. What it does depends on the mode
- of the interpreter (in variable STATE). When STATE is zero, the interpreter just runs
- each word as it looks them up. (Known as immediate mode).
+ pointers (using >CFA) and deciding what to do with them.
+
+ What it does depends on the mode of the interpreter (in variable STATE).
+
+ When STATE is zero, the interpreter just runs each word as it looks them up. This is known as
+ immediate mode.
The interesting stuff happens when STATE is non-zero -- compiling mode. In this mode the
- interpreter just appends the codeword pointers to user memory (the HERE variable points to
- the next free byte of user memory).
+ interpreter appends the codeword pointer to user memory (the HERE variable points to the next
+ free byte of user memory).
So you may be able to see how we could define : (COLON). The general plan is:
(1) Use WORD to read the name of the function being defined.
- (2) Construct the dictionary entry header in user memory:
+ (2) Construct the dictionary entry -- just the header part -- in user memory:
- pointer to previous word (from LATEST) +-- Afterwards, HERE points here, where
+ pointer to previous word (from LATEST) +-- Afterwards, HERE points here, where
^ | the interpreter will start appending
| V codewords.
+--|------+---+---+---+---+---+---+---+---+------------+
+---------+---+---+---+---+---+---+---+---+------------+
len pad codeword
- (3) Set LATEST to point to the newly defined word and most importantly leave HERE pointing
- just after the new codeword. This is where the interpreter will append codewords.
+ (3) Set LATEST to point to the newly defined word, ...
- (4) Set STATE to 1. Go into compile mode so the interpreter starts appending codewords.
+ (4) .. and most importantly leave HERE pointing just after the new codeword. This is where
+ the interpreter will append codewords.
+
+ (5) Set STATE to 1. This goes into compile mode so the interpreter starts appending codewords to
+ our partially-formed header.
After : has run, our input is here:
: DOUBLE DUP + ;
^
|
- Next byte returned by KEY
+ Next byte returned by KEY will be the 'D' character of DUP
- so the interpreter (now it's in compile mode, so I guess it's really the compiler) reads DUP,
- gets its codeword pointer, and appends it:
+ so the interpreter (now it's in compile mode, so I guess it's really the compiler) reads "DUP",
+ looks it up in the dictionary, gets its codeword pointer, and appends it:
+-- HERE updated to point here.
|
len pad codeword
The issue is what happens next. Obviously what we _don't_ want to happen is that we
- read ; and compile it and go on compiling everything afterwards.
+ read ";" and compile it and go on compiling everything afterwards.
At this point, FORTH uses a trick. Remember the length byte in the dictionary definition
isn't just a plain length byte, but can also contain flags. One flag is called the
IMMEDIATE flag (F_IMMED in this code). If a word in the dictionary is flagged as
IMMEDIATE then the interpreter runs it immediately _even if it's in compile mode_.
- I hope I don't need to explain that ; (SEMICOLON) is an IMMEDIATE flagged word. And
- all it does is append the codeword for EXIT on to the current definition and switch
- back to immediate mode (set STATE back to 0). After executing ; we get this:
+ This is how the word ; (SEMICOLON) works -- as a word flagged in the dictionary as IMMEDIATE.
+ And all it does is append the codeword for EXIT on to the current definition and switch
+ back to immediate mode (set STATE back to 0). Shortly we'll see the actual definition
+ of ; and we'll see that it's really a very simple definition, declared IMMEDIATE.
+
+ After the interpreter reads ; and executes it 'immediately', we get this:
+---------+---+---+---+---+---+---+---+---+------------+------------+------------+------------+
| LINK | 6 | D | O | U | B | L | E | 0 | DOCOL | DUP | + | EXIT |
|
HERE
- And that's it, job done, our new definition is compiled.
+ STATE is set to 0.
+
+ And that's it, job done, our new definition is compiled, and we're back in immediate mode
+ just reading and executing words, perhaps including a call to test our new word DOUBLE.
The only last wrinkle in this is that while our word was being compiled, it was in a
half-finished state. We certainly wouldn't want DOUBLE to be called somehow during
being compiled. This prevents FIND from finding it, and thus in theory stops any
chance of it being called.
- Compared to the description above, the actual definition of : (COLON) is comparatively simple:
+ The above explains how compiling, : (COLON) and ; (SEMICOLON) works and in a moment I'm
+ going to define them. The : (COLON) function can be made a little bit more general by writing
+ it in two parts. The first part, called CREATE, makes just the header:
+
+ +-- Afterwards, HERE points here.
+ |
+ V
+ +---------+---+---+---+---+---+---+---+---+
+ | LINK | 6 | D | O | U | B | L | E | 0 |
+ +---------+---+---+---+---+---+---+---+---+
+ len pad
+
+ and the second part, the actual definition of : (COLON), calls CREATE and appends the
+ DOCOL codeword, so leaving:
+
+ +-- Afterwards, HERE points here.
+ |
+ V
+ +---------+---+---+---+---+---+---+---+---+------------+
+ | LINK | 6 | D | O | U | B | L | E | 0 | DOCOL |
+ +---------+---+---+---+---+---+---+---+---+------------+
+ len pad codeword
+
+ CREATE is a standard FORTH word and the advantage of this split is that we can reuse it to
+ create other types of words (not just ones which contain code, but words which contain variables,
+ constants and other data).
*/
- defcode ":",1,,COLON
+ defcode "CREATE",6,,CREATE
- // Get the word and create a dictionary entry header for it.
+ // Get the word.
call _WORD // Returns %ecx = length, %edi = pointer to word.
mov %edi,%ebx // %ebx = address of the word
+ // Link pointer.
movl var_HERE,%edi // %edi is the address of the header
movl var_LATEST,%eax // Get link pointer
stosl // and store it in the header.
+ // Length byte and the word itself.
mov %cl,%al // Get the length.
- orb $F_HIDDEN,%al // Set the HIDDEN flag on this entry.
stosb // Store the length/flags byte.
push %esi
mov %ebx,%esi // %esi = word
addl $3,%edi // Align to next 4 byte boundary.
andl $~3,%edi
- movl $DOCOL,%eax // The codeword for user-created words is always DOCOL (the interpreter)
- stosl
-
- // Header built, so now update LATEST and HERE.
- // We'll be compiling words and putting them HERE.
+ // Update LATEST and HERE.
movl var_HERE,%eax
movl %eax,var_LATEST
movl %edi,var_HERE
-
- // And go into compile mode by setting STATE to 1.
- movl $1,var_STATE
NEXT
/*
- , (COMMA) is a standard FORTH word which appends a 32 bit integer (normally a codeword
- pointer) to the user data area pointed to by HERE, and adds 4 to HERE.
+ Because I want to define : (COLON) in FORTH, not assembler, we need a few more FORTH words
+ to use.
+
+ The first is , (COMMA) which is a standard FORTH word which appends a 32 bit integer to the user
+ data area pointed to by HERE, and adds 4 to HERE. So the action of , (COMMA) is:
+
+ previous value of HERE
+ |
+ V
+ +---------+---+---+---+---+---+---+---+---+-- - - - - --+------------+
+ | LINK | 6 | D | O | U | B | L | E | 0 | | <data> |
+ +---------+---+---+---+---+---+---+---+---+-- - - - - --+------------+
+ len pad ^
+ |
+ new value of HERE
+
+ and <data> is whatever 32 bit integer was at the top of the stack.
+
+ , (COMMA) is quite a fundamental operation when compiling. It is used to append codewords
+ to the current word that is being compiled.
*/
defcode ",",1,,COMMA
ret
/*
- ; (SEMICOLON) is also elegantly simple. Notice the F_IMMED flag.
+ Our definitions of : (COLON) and ; (SEMICOLON) will need to switch to and from compile mode.
+
+ Immediate mode vs. compile mode is stored in the global variable STATE, and by updating this
+ variable we can switch between the two modes.
+
+ For various reasons which may become apparent later, FORTH defines two standard words called
+ [ and ] (LBRAC and RBRAC) which switch between modes:
+
+ Word Assembler Action Effect
+ [ LBRAC STATE := 0 Switch to immediate mode.
+ ] RBRAC STATE := 1 Switch to compile mode.
+
+ [ (LBRAC) is an IMMEDIATE word. The reason is as follows: If we are in compile mode and the
+ interpreter saw [ then it would compile it rather than running it. We would never be able to
+ switch back to immediate mode! So we flag the word as IMMEDIATE so that even in compile mode
+ the word runs immediately, switching us back to immediate mode.
*/
- defcode ";",1,F_IMMED,SEMICOLON
- movl $EXIT,%eax // EXIT is the final codeword in compiled words.
- call _COMMA // Store it.
- call _HIDDEN // Toggle the HIDDEN flag (unhides the new word).
- xor %eax,%eax // Set STATE to 0 (back to execute mode).
- movl %eax,var_STATE
+ defcode "[",1,F_IMMED,LBRAC
+ xor %eax,%eax
+ movl %eax,var_STATE // Set STATE to 0.
NEXT
+ defcode "]",1,,RBRAC
+ movl $1,var_STATE // Set STATE to 1.
+ NEXT
+
+/*
+ Now we can define : (COLON) using CREATE. It just calls CREATE, appends DOCOL (the codeword), sets
+ the word HIDDEN and goes into compile mode.
+*/
+
+ defword ":",1,,COLON
+ .int CREATE // CREATE the dictionary entry / header
+ .int LIT, DOCOL, COMMA // Append DOCOL (the codeword).
+ .int LATEST, FETCH, HIDDEN // Make the word hidden (see below for definition).
+ .int RBRAC // Go into compile mode.
+ .int EXIT // Return from the function.
+
+/*
+ ; (SEMICOLON) is also elegantly simple. Notice the F_IMMED flag.
+*/
+
+ defword ";",1,F_IMMED,SEMICOLON
+ .int LIT, EXIT, COMMA // Append EXIT (so the word will return).
+ .int LATEST, FETCH, HIDDEN // Toggle hidden flag -- unhide the word (see below for definition).
+ .int LBRAC // Go back to IMMEDIATE mode.
+ .int EXIT // Return from the function.
+
/*
- IMMEDIATE mode words aren't just for the FORTH compiler to use. You can define your
- own IMMEDIATE words too. The IMMEDIATE word toggles the F_IMMED (IMMEDIATE flag) on the
- most recently defined word, or on the current word if you call it in the middle of a
- definition.
+ EXTENDING THE COMPILER ----------------------------------------------------------------------
+
+ Words flagged with IMMEDIATE (F_IMMED) aren't just for the FORTH compiler to use. You can define
+ your own IMMEDIATE words too, and this is a crucial aspect when extending basic FORTH, because
+ it allows you in effect to extend the compiler itself. Does gcc let you do that?
+
+ Standard FORTH words like IF, WHILE, ." and so on are all written as extensions to the basic
+ compiler, and are all IMMEDIATE words.
+
+ The IMMEDIATE word toggles the F_IMMED (IMMEDIATE flag) on the most recently defined word,
+ or on the current word if you call it in the middle of a definition.
Typical usage is:
...definition...
; IMMEDIATE
- The two are basically equivalent.
+ The two usages are equivalent, to a first approximation.
*/
defcode "IMMEDIATE",9,F_IMMED,IMMEDIATE
- call _IMMEDIATE
- NEXT
-_IMMEDIATE:
movl var_LATEST,%edi // LATEST word.
addl $4,%edi // Point to name/flags byte.
xorb $F_IMMED,(%edi) // Toggle the IMMED bit.
- ret
+ NEXT
/*
- HIDDEN toggles the other flag, F_HIDDEN, of the latest word. Note that words flagged
- as hidden are defined but cannot be called, so this is rarely used.
+ 'addr HIDDEN' toggles the hidden flag (F_HIDDEN) of the word defined at addr. To hide the
+ most recently defined word (used above in : and ; definitions) you would do:
+
+ LATEST @ HIDDEN
+
+ Setting this flag stops the word from being found by FIND, and so can be used to make 'private'
+ words. For example, to break up a large word into smaller parts you might do:
+
+ : SUB1 ... subword ... ;
+ : SUB2 ... subword ... ;
+ : SUB3 ... subword ... ;
+ : MAIN ... defined in terms of SUB1, SUB2, SUB3 ... ;
+ WORD SUB1 FIND HIDDEN \ Hide SUB1
+ WORD SUB2 FIND HIDDEN \ Hide SUB2
+ WORD SUB3 FIND HIDDEN \ Hide SUB3
+
+ After this, only MAIN is 'exported' or seen by the rest of the program.
*/
defcode "HIDDEN",6,,HIDDEN
- call _HIDDEN
- NEXT
-_HIDDEN:
- movl var_LATEST,%edi // LATEST word.
+ pop %edi // Dictionary entry.
addl $4,%edi // Point to name/flags byte.
xorb $F_HIDDEN,(%edi) // Toggle the HIDDEN bit.
- ret
+ NEXT
/*
' (TICK) is a standard FORTH word which returns the codeword pointer of the next word.
and immediate mode).
This definition of ' uses a cheat which I copied from buzzard92. As a result it only works in
- compiled code.
+ compiled code. It is possible to write a version of ' based on WORD, FIND, >CFA which works in
+ immediate mode too.
*/
defcode "'",1,,TICK
lodsl // Get the address of the next word and skip it.
BRANCH is an unconditional branch. 0BRANCH is a conditional branch (it only branches if the
top of stack is zero).
- This is how BRANCH works. When BRANCH executes, %esi starts by pointing to the offset:
+ The diagram below shows how BRANCH works in some imaginary compiled word. When BRANCH executes,
+ %esi starts by pointing to the offset field (compare to LIT above):
+---------------------+-------+---- - - ---+------------+------------+---- - - - ----+------------+
| (Dictionary header) | DOCOL | | BRANCH | offset | (skipped) | word |
0BRANCH is the same except the branch happens conditionally.
- Now standard FORTH words such as IF, THEN, ELSE, WHILE, REPEAT, etc. are implemented entirely
+ Now standard FORTH words such as IF, THEN, ELSE, WHILE, REPEAT, etc. can be implemented entirely
in FORTH. They are IMMEDIATE words which append various combinations of BRANCH or 0BRANCH
into the word currently being compiled.
NEXT
/*
- PRINTING STRINGS ----------------------------------------------------------------------
+ LITERAL STRINGS ----------------------------------------------------------------------
- LITSTRING and EMITSTRING are primitives used to implement the ." operator (which is
- written in FORTH). See the definition of that operator below.
+ LITSTRING is a primitive used to implement the ." and S" operators (which are written in
+ FORTH). See the definition of those operators later.
+
+ TELL just prints a string. It's more efficient to define this in assembly because we
+ can make it a single Linux syscall.
*/
defcode "LITSTRING",9,,LITSTRING
lodsl // get the length of the string
- push %eax // push it on the stack
push %esi // push the address of the start of the string
+ push %eax // push it on the stack
addl %eax,%esi // skip past the string
- addl $3,%esi // but round up to next 4 byte boundary
+ addl $3,%esi // but round up to next 4 byte boundary
andl $~3,%esi
NEXT
- defcode "EMITSTRING",10,,EMITSTRING
+ defcode "TELL",4,,TELL
mov $1,%ebx // 1st param: stdout
- pop %ecx // 2nd param: address of string
pop %edx // 3rd param: length of string
+ pop %ecx // 2nd param: address of string
mov $__NR_write,%eax // write syscall
int $0x80
NEXT
COLD is the first FORTH function called, almost immediately after the FORTH system "boots".
- INTERPRETER is the FORTH interpreter ("toploop", "toplevel" or REPL might be a more accurate
- description).
+ INTERPRETER is the FORTH interpreter ("toploop", "toplevel" or "REPL" might be a more accurate
+ description -- see: http://en.wikipedia.org/wiki/REPL).
*/
-
// COLD must not return (ie. must not call EXIT).
defword "COLD",4,,COLD
.int INTERPRETER // call the interpreter loop (never returns)
CHAR puts the ASCII code of the first character of the following word on the stack. For example
CHAR A puts 65 on the stack.
- SYSEXIT pops the status off the stack and exits the process (using Linux exit syscall).
+ SYSEXIT exits the process using Linux exit syscall.
+
+ In this FORTH, SYSEXIT must be the last word in the built-in (assembler) dictionary because we
+ initialise the LATEST variable to point to it. This means that if you want to extend the assembler
+ part, you must put new words before SYSEXIT, or else change how LATEST is initialised.
*/
defcode "CHAR",4,,CHAR
words can be written as FORTH itself, including words like IF, THEN, .", etc which in most
languages would be considered rather fundamental.
- As a kind of trick, I prefill the input buffer with the initial FORTH code. Once this code
- has run (when we get to the "OK" prompt), this input buffer is reused for reading user input.
-
- Some notes about the code:
-
- \ (backslash) is the FORTH way to start a comment which goes up to the next newline. However
- because this is a C-style string, I have to escape the backslash, which is why they appear as
- \\ comment.
-
- Similarly, any backslashes in the code are doubled, and " becomes \" (eg. the definition of ."
- is written as : .\" ... ;)
+ I used to append this here in the assembly file, but I got sick of fighting against gas's
+ stupid (lack of) multiline string syntax. So now that is in a separate file called jonesforth.f
- I use indenting to show structure. The amount of whitespace has no meaning to FORTH however
- except that you must use at least one whitespace character between words, and words themselves
- cannot contain whitespace.
-
- FORTH is case-sensitive. Use capslock!
-
- Enjoy!
+ If you don't already have that file, download it from http://annexia.org/forth in order
+ to continue the tutorial.
*/
- .data
- .align 4096
-buffer:
- // Multi-line constant gives 'Warning: unterminated string; newline inserted' messages which you can ignore
- .ascii "\
-\\ Define some character constants
-: '\\n' 10 ;
-: 'SPACE' 32 ;
-: '\"' 34 ;
-: ':' 58 ;
-
-\\ CR prints a carriage return
-: CR '\\n' EMIT ;
-
-\\ SPACE prints a space
-: SPACE 'SPACE' EMIT ;
-
-\\ Primitive . (DOT) function doesn't follow with a blank, so redefine it to behave like FORTH.
-\\ Notice how we can trivially redefine existing functions.
-: . . SPACE ;
-
-\\ DUP, DROP are defined in assembly for speed, but this is how you might define them
-\\ in FORTH. Notice use of the scratch variables _X and _Y.
-\\ : DUP _X ! _X @ _X @ ;
-\\ : DROP _X ! ;
-
-\\ The 2... versions of the standard operators work on pairs of stack entries. They're not used
-\\ very commonly so not really worth writing in assembler. Here is how they are defined in FORTH.
-: 2DUP OVER OVER ;
-: 2DROP DROP DROP ;
-
-\\ More standard FORTH words.
-: 2* 2 * ;
-: 2/ 2 / ;
-
-\\ [ and ] allow you to break into immediate mode while compiling a word.
-: [ IMMEDIATE \\ define [ as an immediate word
- 0 STATE ! \\ go into immediate mode
- ;
-
-: ]
- 1 STATE ! \\ go back to compile mode
- ;
-
-\\ LITERAL takes whatever is on the stack and compiles LIT <foo>
-: LITERAL IMMEDIATE
- ' LIT , \\ compile LIT
- , \\ compile the literal itself (from the stack)
- ;
-
-\\ condition IF true-part THEN rest
-\\ compiles to:
-\\ condition 0BRANCH OFFSET true-part rest
-\\ where OFFSET is the offset of 'rest'
-\\ condition IF true-part ELSE false-part THEN
-\\ compiles to:
-\\ condition 0BRANCH OFFSET true-part BRANCH OFFSET2 false-part rest
-\\ where OFFSET if the offset of false-part and OFFSET2 is the offset of rest
-
-\\ IF is an IMMEDIATE word which compiles 0BRANCH followed by a dummy offset, and places
-\\ the address of the 0BRANCH on the stack. Later when we see THEN, we pop that address
-\\ off the stack, calculate the offset, and back-fill the offset.
-: IF IMMEDIATE
- ' 0BRANCH , \\ compile 0BRANCH
- HERE @ \\ save location of the offset on the stack
- 0 , \\ compile a dummy offset
-;
-
-: THEN IMMEDIATE
- DUP
- HERE @ SWAP - \\ calculate the offset from the address saved on the stack
- SWAP ! \\ store the offset in the back-filled location
-;
-
-: ELSE IMMEDIATE
- ' BRANCH , \\ definite branch to just over the false-part
- HERE @ \\ save location of the offset on the stack
- 0 , \\ compile a dummy offset
- SWAP \\ now back-fill the original (IF) offset
- DUP \\ same as for THEN word above
- HERE @ SWAP -
- SWAP !
-;
-
-\\ BEGIN loop-part condition UNTIL
-\\ compiles to:
-\\ loop-part condition 0BRANCH OFFSET
-\\ where OFFSET points back to the loop-part
-\\ This is like do { loop-part } while (condition) in the C language
-: BEGIN IMMEDIATE
- HERE @ \\ save location on the stack
-;
-
-: UNTIL IMMEDIATE
- ' 0BRANCH , \\ compile 0BRANCH
- HERE @ - \\ calculate the offset from the address saved on the stack
- , \\ compile the offset here
-;
-
-\\ BEGIN loop-part AGAIN
-\\ compiles to:
-\\ loop-part BRANCH OFFSET
-\\ where OFFSET points back to the loop-part
-\\ In other words, an infinite loop which can only be returned from with EXIT
-: AGAIN IMMEDIATE
- ' BRANCH , \\ compile BRANCH
- HERE @ - \\ calculate the offset back
- , \\ compile the offset here
-;
-
-\\ BEGIN condition WHILE loop-part REPEAT
-\\ compiles to:
-\\ condition 0BRANCH OFFSET2 loop-part BRANCH OFFSET
-\\ where OFFSET points back to condition (the beginning) and OFFSET2 points to after the whole piece of code
-\\ So this is like a while (condition) { loop-part } loop in the C language
-: WHILE IMMEDIATE
- ' 0BRANCH , \\ compile 0BRANCH
- HERE @ \\ save location of the offset2 on the stack
- 0 , \\ compile a dummy offset2
-;
-
-: REPEAT IMMEDIATE
- ' BRANCH , \\ compile BRANCH
- SWAP \\ get the original offset (from BEGIN)
- HERE @ - , \\ and compile it after BRANCH
- DUP
- HERE @ SWAP - \\ calculate the offset2
- SWAP ! \\ and back-fill it in the original location
-;
-
-\\ With the looping constructs, we can now write SPACES, which writes n spaces to stdout.
-: SPACES
- BEGIN
- SPACE \\ print a space
- 1- \\ until we count down to 0
- DUP 0=
- UNTIL
-;
-
-\\ .S prints the contents of the stack. Very useful for debugging.
-: .S
- DSP@ \\ get current stack pointer
- BEGIN
- DUP @ . \\ print the stack element
- 4+ \\ move up
- DUP S0 @ 4- = \\ stop when we get to the top
- UNTIL
- DROP
-;
-
-\\ DEPTH returns the depth of the stack.
-: DEPTH S0 @ DSP@ - ;
-
-\\ .\" is the print string operator in FORTH. Example: .\" Something to print\"
-\\ The space after the operator is the ordinary space required between words.
-\\ This is tricky to define because it has to do different things depending on whether
-\\ we are compiling or in immediate mode. (Thus the word is marked IMMEDIATE so it can
-\\ detect this and do different things).
-\\ In immediate mode we just keep reading characters and printing them until we get to
-\\ the next double quote.
-\\ In compile mode we have the problem of where we're going to store the string (remember
-\\ that the input buffer where the string comes from may be overwritten by the time we
-\\ come round to running the function). We store the string in the compiled function
-\\ like this:
-\\ LITSTRING, string length, string rounded up to 4 bytes, EMITSTRING, ...
-: .\" IMMEDIATE
- STATE @ \\ compiling?
- IF
- ' LITSTRING , \\ compile LITSTRING
- HERE @ \\ save the address of the length word on the stack
- 0 , \\ dummy length - we don't know what it is yet
- BEGIN
- KEY \\ get next character of the string
- DUP '\"' <>
- WHILE
- HERE @ !b \\ store the character in the compiled image
- 1 HERE +! \\ increment HERE pointer by 1 byte
- REPEAT
- DROP \\ drop the double quote character at the end
- DUP \\ get the saved address of the length word
- HERE @ SWAP - \\ calculate the length
- 4- \\ subtract 4 (because we measured from the start of the length word)
- SWAP ! \\ and back-fill the length location
- HERE @ \\ round up to next multiple of 4 bytes for the remaining code
- 3 +
- 3 INVERT AND
- HERE !
- ' EMITSTRING , \\ compile the final EMITSTRING
- ELSE
- \\ In immediate mode, just read characters and print them until we get
- \\ to the ending double quote. Much simpler than the above code!
- BEGIN
- KEY
- DUP '\"' = IF EXIT THEN
- EMIT
- AGAIN
- THEN
-;
-
-\\ While compiling, [COMPILE] WORD compiles WORD if it would otherwise be IMMEDIATE.
-: [COMPILE] IMMEDIATE
- WORD \\ get the next word
- FIND \\ find it in the dictionary
- >CFA \\ get its codeword
- , \\ and compile that
-;
-
-\\ RECURSE makes a recursive call to the current word that is being compiled.
-\\ Normally while a word is being compiled, it is marked HIDDEN so that references to the
-\\ same word within are calls to the previous definition of the word.
-: RECURSE IMMEDIATE
- LATEST @ >CFA \\ LATEST points to the word being compiled at the moment
- , \\ compile it
-;
-
-\\ ALLOT is used to allocate (static) memory when compiling. It increases HERE by
-\\ the amount given on the stack.
-: ALLOT HERE +! ;
-
-
-\\ Finally print the welcome prompt.
-.\" OK \"
-"
-
-_initbufftop:
- .align 4096
-buffend:
-
-currkey:
- .int buffer
-bufftop:
- .int _initbufftop
-
/* END OF jonesforth.S */
git.annexia.org / jonesforth.git / blobdiff