\ Lesson 9 - Compiler Words
\ The Forth Course
\ by Richard E. Haskell
\ Dept. of Computer Science and Engineering
\ Oakland University, Rochester, MI 48309
comment:
Lesson 9
COMPILER WORDS
9.1 COMPILING VS. INTERPRETING 9-2
9.2 COMPILE AND [COMPILE] 9-5
9.3 LITERALS 9-6
9.4 CONDITIONAL COMPILER WORDS 9-8
BEGIN...WHILE...REPEAT 9-9
IF...ELSE...THEN 9-10
BEGIN...AGAIN 9-11
BEGIN...UNTIL 9-12
DO...LOOP 9-13
9.5 EXERCISES 9-14
9.1 COMPILING VS. INTERPRETING
Compiler words are IMMEDIATE words. This means that they are
executed immediately when they are encountered in a colon
definition rather than being compiled into the list segment.
Immediate words have the precedence bit in the name field set
(see Lesson 3, Section 3.12).
F-PC can be in one of two possible states: compiling or interpreting.
It is in the compiling state during the compilation of a colon
definition. That is, between the time the word "colon" (:) is
executed and the word "semi-colon" (;) is executed.
The system variable STATE contains the following possible two values:
TRUE -- if compiling
FALSE -- if interpreting
To test what state exists at different times, consider the following
two definitions:
comment;
: 1state? ( -- )
STATE @
IF
." Compiling"
ELSE
." Interpreting"
THEN
CR ;
: 1test ( -- )
1state? ;
comment:
After FLOADing lesson9 type
1state?
and
1test
Note that "interpreting" is printed in each case. Why?
It is because you are in the interpreting mode when you type both
1state? and 1test.
How can you get "Compiling" to be printed?
It is necessary to have 1state? execute during the time that
1test is being compiled. That is, we must make 1state? an
immediate word. We do this by adding the word IMMEDIATE to the
definition following the semi-colon. Let's change the name to
2state? and define
comment;
: 2state? ( -- )
STATE @
IF
." Compiling"
ELSE
." Interpreting"
THEN
CR ; IMMEDIATE
comment:
Now type in the following colon definition:
: 2test 2state? ;
Note that when you type this definition, the word "Compiling"
is printed as soon as you press <Enter>. That is, the word
2state? is executed immediately and does not wait for you to
later type 2test. Now type
2test
Note that nothing is printed on the screen. This is because
2state? was not compiled in the dictionary. It was just executed
immediately. Immediate words do not get compiled in the dictionary
unless forced to do so. You can force an immediate word to be
compiled, rather than be executed immediately, by preceding the
word by [COMPILE]. Thus, in the following definition of 3test
the word 2state? is compiled and not executed immediately.
comment;
: 3test ( -- )
[COMPILE] 2state? ;
comment:
What do you think will be printed when you type 3test? Try it.
It is also possible to turn the compiler off and on within a colon
definition by using the two words [ and ].
The word [ is an immediate word that turns the compiling state off;
that is, it returns to the interpreting mode. The definition of [ is
: [ ( -- )
STATE OFF ; IMMEDIATE
The word ] turns the compile mode on and then enters the compiling
loop. The compiling loop consists of the following:
DO Get next word in input stream;
If it is an immediate word, execute it
Else compile it;
If the word is not in the dictionary,
convert it to a number and compile it;
UNTIL end of input stream.
An a final example, type in the following example:
: 4test [ 1state? ] ;
Note that when you press <Enter> the word "interpreting" is printed.
Why?
9.2 COMPILE AND [COMPILE]
We have seen that [COMPILE] will compile the following immediate
word into the list segment. Its definition is
: [COMPILE] ( -- )
' X, ; IMMEDIATE
The word "tick" (') will put the CFA of the next (immediate) word
on the stack and the word X, compiles the integer on the stack
into the next available location in the list dictionary. Note that
[COMPILE] itself is an immediate word so that it is executed at
compile time of the word that contains it.
Sometimes you want to compile a word at run time. The word COMPILE
will do this. For example, the definition of "semi-colon" is
basically the following.
: ; ( -- )
COMPILE UNNEST \ compile the UNNEST routine
REVEAL \ make the colon word available
[COMPILE] [ \ go to interpreting mode
; IMMEDIATE \ do ; immediately
Note that ; is an immediate word so that it will be executed when
it is encountered in a colon definition. It will COMPILE the CFA
of the UNNEST routine in the list dictionary of the colon word.
After making the colon word available to dictionary searches by the
word REVEAL it switches to the interpreting mode by executing [
which had been compiled in the definition of ; (even though [ is
an immediate word) by [COMPILE].
The definition of [COMPILE], which will compile the CFA of the
following non-immediate word when the word containing COMPILE
executes, is the following
: COMPILE ( -- )
2R@ SWAP \ get ES:SI of next CFA in list seg
R> 2+ >R \ inc SI past next word in list seg
@L \ get CFA on next word in list seg
,X ; \ & compile it at run time
9.3 LITERALS
Consider the following colon definition:
comment;
: four+ ( n -- n+4 )
4 + ;
comment:
This will be compiled into the dictionary as follows:
four+
________ |
CFA | CODE | <------|
|------| _________
PFA | LSO | -------- +XSEG -------> | (LIT) | ES:0
|------| |-------|
Code Segment ?CS: | 4 | IP = ES:SI
|-------|
| + |
|-------|
|UNNEST |
|-------|
List Segment XSEG
The word (LIT) is a code word defined as follows:
CODE (LIT) ( -- n )
LODSW ES: \ get next word at ES:SI, SI=SI+2
1PUSH \ push it on stack
END-CODE
Thus the word (LIT) will push the number 4 on the stack and the
instruction pointer ES:SI will then be pointing to the CFA of +.
If you have a number on the stack and you want to compile it as
a literal in the list dictionary you can use the word LITERAL.
This word is defined as follows:
: LITERAL ( n -- )
COMPILE (LIT) \ compile (LIT)
X, \ plus the value n
; IMMEDIATE \ immediately
A useful application of the word LITERAL is when you compute
some constant value in a definition. For example, suppose that
the value 5 is computed as 2 + 3 (perhaps for clarity in some
definition). You might then define the word five+ as follows:
comment;
: five+ ( n -- n+5 )
[ 3 2 + ] LITERAL + ;
comment:
Although this produces the same answer as
: five+ 3 2 + + ;
the advantange is that [ 3 2 + ] LITERAL will compile the literal
5 in the list dictionary at compile time so that at run time only
5 + is executed. On the other hand, 3 2 + + will compile both a
literal 3 and a literal 2 in the list dictionary and will execute
two plus operations at run time. Therefore, the use of
[ 3 2 + ] LITERAL produces more efficient code that executes faster.
9.4 CONDITIONAL COMPILER WORDS
The two conditional compiler words BRANCH and ?BRANCH are used
to define the various conditional branching instructions in F-PC.
The word BRANCH is a code word that is defined as follows:
|-------|
CODE BRANCH ( -- ) |BRANCH |
LABEL BRAN1 |-------|
MOV ES: SI, 0[SI] |----| addr | IP = ES:SI
NEXT | |-------|
END-CODE | | |
| |-------|
| | |
| |-------|
|--->| | ES:addr
|-------|
| |
|-------|
List Segment XSEG
BRANCH is compiled into the list dictionary followed by the
offset address that is to be unconditionally branched to.
The word ?BRANCH will cause a branch to the address following
?BRANCH if the flag on top of the stack is FALSE. It is defined
as follows:
|-------|
CODE ?BRANCH ( f -- ) |?BRANCH|
POP AX |-------|
OR AX, AX |----| addr | IP = ES:SI
JE BRAN1 | |-------|
ADD SI, # 2 | | |
NEXT | |-------|
END-CODE | | |
| |-------|
|--->| | ES:addr
|-------|
| |
|-------|
List Segment XSEG
BEGIN...WHILE...REPEAT
As an example of a BEGIN...WHILE...REPEAT loop recall the
definition of the word "factorial" given in Lesson 4:
: factorial ( n -- n! )
1 2 ROT \ x i n
BEGIN \ x i n
2DUP <= \ x i n f
WHILE \ x i n
-ROT TUCK \ n i x i
* SWAP \ n x i
1+ ROT \ x i n
REPEAT \ x i n
2DROP ; \ x
This definition will be stored in the list dictionary as follows:
_________
| (LIT) |
|-------|
| 1 | XHERE ( -- seg offset )
|-------|
| (LIT) |
|-------|
| 2 |
STACK |-------|
| ROT |
|-------|
xhere1 ---> | 2DUP | <--- : BEGIN XHERE NIP ; IMMEDIATE
|-------|
| <= |
|-------|
|?BRANCH| <--- : WHILE COMPILE ?BRANCH
xhere1 |-------| XHERE NIP 0 X,
xhere2 ---> | 0 | <---| SWAP ; IMMEDIATE
|-------| |
| -ROT | |
|-------| |
| TUCK | | xhere3
|-------| |
| * | |
|-------| |
| SWAP | |
|-------| |
| 1+ | |
|-------| |
| ROT | |
|-------| |
| BRANCH| | <--- : REPEAT COMPILE BRANCH X,
|-------| | XHERE -ROT
| xhere1| |-------------- SWAP !L ;
|-------| IMMEDIATE
xhere3 ---> | 2DROP |
seg |-------|
xhere2 |UNNEST |
|-------|
List Segment XSEG
The word BEGIN leaves the offset address xhere1 on the stack.
The word WHILE compiles ?BRANCH followed by a 0 at xhere2.
This value of 0 will later be replaced with the address xhere3
of the word 2DROP. WHILE also leaves the value of xhere2 on the
stack under xhere1.
The word REPEAT compiles BRANCH and then commas in the address
xhere1. It then puts the address xhere3 on the stack and then
stores it at address seg:xhere2.
IF...ELSE...THEN
Consider the following colon definition:
: test ( f -- f )
IF
TRUE
ELSE
FALSE
THEN ;
This will be stored in the list dictionary as follows:
_________
|?BRANCH| <--- : IF COMPILE ?BRANCH
|-------| XHERE NIP 0 X,
xhere1 ---> | 0 | <---| ; IMMEDIATE
|-------| |
| TRUE | |xhere3
|-------| |
| BRANCH| | <--- : ELSE COMPILE BRANCH
|-------| | XHERE NIP 0 X,
xhere2 ---> | 0 |<--| | SWAP XHERE
|-------| | |------------ -ROT SWAP !L
xhere3 ---> | FALSE | |xhere4 ; IMMEDIATE
|-------| |
xhere4 ---> |UNNEST | | <--- : THEN XHERE
|-------| |------------ -ROT SWAP !L
; IMMEDIATE
List Segment XSEG
The word IF compiles ?BRANCH followed by a 0 at xhere1.
This value of 0 will later be replaced with the address xhere3
of the word FALSE. IF also leaves the value of xhere1 on the
stack.
The word ELSE compiles BRANCH followed by a 0 at xhere2.
This value of 0 will later be replaced with the address xhere4
of the word UNNEST. ELSE also leaves the value of xhere2 on the
stack after putting the address xhere3 on the stack and then
storing it at address seg:xhere1.
The word THEN puts the address xhere4 on the stack and then
stores it at address seg:xhere2.
BEGIN...AGAIN
An example of a using BEGIN...AGAIN was given in the pop-up menu
examples in Lesson 8. The typical form was
: main ( -- )
minit
BEGIN
KEY do.key
AGAIN ;
This will be stored in the list dictionary as follows:
_________
| minit |
|-------|
xhere1 ---> | KEY | <--- : BEGIN XHERE NIP ; IMMEDIATE
|-------|
| do.key|
|-------|
| BRANCH| <--- : AGAIN COMPILE BRANCH X,
|-------| ; IMMEDIATE
| xhere1|
|-------|
|UNNEST |
|-------|
List Segment XSEG
The word BEGIN leaves the offset address xhere1 on the stack.
The word AGAIN compiles BRANCH and then commas in the address
xhere1.
BEGIN...UNTIL
The following example of a using BEGIN...UNTIL was given in
Lesson 4.
: dowrite ( -- )
BEGIN
KEY
DUP EMIT
13 =
UNTIL ;
This will be stored in the list dictionary as follows:
_________
xhere1 ---> | KEY | <--- : BEGIN XHERE NIP ; IMMEDIATE
|-------|
| DUP |
|-------|
| EMIT |
|-------|
| (LIT) |
|-------|
| 13 |
|-------|
| = |
|-------|
|?BRANCH| <--- : UNTIL COMPILE ?BRANCH X,
|-------| ; IMMEDIATE
| xhere1|
|-------|
|UNNEST |
|-------|
List Segment XSEG
The word BEGIN leaves the offset address xhere1 on the stack.
The word UNTIL compiles ?BRANCH and then commas in the address
xhere1. Note that the only difference between BEGIN...AGAIN and
BEGIN...UNTIL is that in UNTIL ?BRANCH replaces the BRANCH in
AGAIN.
DO...LOOP
A DO loop will produce the following structure in the list
dictionary:
__________
| (DO) | <--- : DO COMPILE (DO)
|--------| XHERE NIP 0 X,
xhere1 ---> | 0 | <---| ; IMMEDIATE
|--------| |
xhere1 + 2 ---> | |<--| |xhere2
|--------| | |
| | | |
|--------| | |
| | | |
|--------| | |
| (LOOP) | | | <--- : LOOP COMPILE (LOOP)
|--------| | | DUP 2+ X,
|xhere1+2|---| | XHERE
|--------| |----------- -ROT SWAP !L
xhere2 ---> | | ; IMMEDIATE
|--------|
List Segment XSEG
The word DO compiles (DO) followed by a 0 at xhere1.
This value of 0 will later be replaced with the address xhere2
of the first word following the DO loop. DO also leaves the
value of xhere1 on the stack.
The word LOOP compiles (LOOP) and then commas in the address
xhere1+2. LOOP then puts the address xhere2 on the stack and
then stores it at address seg:xhere1.
The run-time word
(DO) ( limit index -- )
sets up the return stack as follows:
Return Stack
___________________________
| index - (limit + 8000H) |
|-------------------------|
| limit + 8000H |
|-------------------------|
| xhere2 |
|-------------------------|
The run-time word (LOOP) adds 1 to the top of the return stack
and jumps to xhere1+2 if the overflow flag is not set. If the
overflow flag is set (i.e. the top of the stack crosses the
8000H boundary when index = limit) (LOOP) pops the three items
from the return stack and moves the instruction pointer ES:SI
to xhere2.
Having the value of xhere2 as the third item on the return stack
is used by LEAVE to find the address to leave to. Adding the
value of 8000H to the top two values on the return stack when
executing (DO) allows the DO loop to work properly when the limit
is larger than 8000H. For example, suppose the limit were FFFFH
and the initial index were 0. The initial value on top of the
return stack would be -7FFFH. As 1 is added to this value, the
overflow flag will not be set until the top of the stack becomes
equal to 8000H, that is, after FFFFH loops.
9.5 EXERCISES
9.1 Use the words SEE and LDUMP to investigate the dictionary
structure of the following three test words:
comment;
: a.test ( f -- )
IF
." True"
ELSE
." False"
THEN ;
: b.test ( -- )
5 0 DO
I .
LOOP ;
: c.test ( -- )
4
BEGIN
DUP .
1- DUP 0=
UNTIL
DROP ;
comment:
For each word draw the dictionary structure indicating the names
and actual values of all entries in the list dictionary. Indicate
on these drawings the effects of the words IF, ELSE, THEN, DO,
LOOP, BEGIN and UNTIL. Also explain how the word ." works in
a.test and how the numbers 5, 0 and 4 are stored in b.test and
c.test.
comment;