DEFER/IS

For Alfred

Deferred words in Forth are words that exist, but don't do anything yet. Before a word can be compiled into a definition, it has to exist. Sometimes, you want the word to exist without any code. There are a few reasons for doing this:

Perhaps you're just fleshing out ideas, and you don't know what code a particular word will have yet;
You want a word to execute one bit of code or another, but you're not quite sure;
You want to change the code that a word executes without having to re-compile your application.

DEFER and its partner word, IS allows you to do the above very easily. Consider the following:

    DEFER UpDown

This creates a word in the dictionary that can execute some code. What code? Well, that's the cool part. We can attach the code that we want this word to execute later on. Or, we can even change it. We can even change it in a running program if we want to.

Let's create a little program that either counts up or down. We'll get the same program to count up or down without having to compile it. Here's the code:

DEFER UpDown : Counter ( -- ) 0 BEGIN UpDown DUP . KEY? 32 = UNTIL DROP ;

If you type in the above program (you'll need to load DEFER/IS from block 73 on the utilities disk) you'll see that it compiles just fine, but if you try and run it (by typing Counter) then you get an error: Deferred action not set. What does this mean? Well, clearly, deferring something means leaving something until later. In the case of deferred words in Forth, you're creating a word, but you are deferring the run-time behaviour of that word until later. So, before we can run the above program, we need to associate UpDown with some code, or another word, so that it can actually do something when executed. We do that with the word ' (which is pronounced tick).

Execution Tokens

When we 'tick' a word, we get back its execution token. This is simply an address (at least, it is in TurboForth). If we supply that address to EXECUTE (via the stack) then we can execute a word via its execution token. Try this:

    ' WORDS EXECUTE

Here, ' (tick) looked up the address of WORDS and placed it on the stack. EXECUTE took that address, and executed the code at that address, which causes WORDS to execute (obviously).

We use the same techinque to associate a deferred word with some code to execute.

IS

Let's expand the little example program:

DEFER UpDown : Counter ( -- ) 0 BEGIN UpDown DUP . KEY? 32 = UNTIL DROP ; : CountUp ( n -- n+1) 1+ ; : CountDown ( n -- n-1) 1- ;

Now, type the following:

    ' CountUp IS UpDown

And then execute the program by typing Counter.

Ta dah! Our program is counting upwards. Of course, normally, we'd have to define CountUp before we defined Counter, but we created a deferred word (UpDown) that satisfied the compiler (i.e. the UpDown existed when the compiler encountered it, so the compiler was happy). We associated the action of UpDown later on, when we knew what we wanted it to do.

Stop the program by pressing the space bar. Now type the following:

    ' CountDown IS UpDown

Now type Counter again. Now we're counting down.

You can probably see now, that it is possible to write code using a deferred word and change its action later. This is great when you're de-bugging. Perhaps you're working on a word, and you haven't got it quite right yet. You create a deferred word, compile it into your program, then you create test words (TEST1, TEST2, TEST3) and associate your deferred word with the test words and re-run your program. This saves you the hassle of having to re-compile your program every time you make a change.

It's even possible to change the action of a deferred word at run-time, while your program is running. This is done with the word DEFER!.

DEFER!

The stack signature of DEFER! (pronounced "defer store") is as follows:

    DEFER! ( xt1 xt2 -- )

It takes the execution token xt1 (found with tick, or its run-time counter-part ['] (also pronounced tick - just to confuse you) and stores it in the execution token of the deferred word xt2 (also obtained with ' or [']). For example:

    ' CountUp ' UpDown DEFER!

Let's modify the test program above such that we can change the action of the deferred word (UpDown) at run-time...

DEFER UpDown : CountUp ( n -- n+1) 1+ ; : CountDown ( n -- n-1) 1- ; : Counter ( -- ) 0 BEGIN UpDown DUP . KEY? CASE 32 OF DROP EXIT ENDOF ASCII U OF ['] CountUp ['] UpDown DEFER! ENDOF ASCII D OF ['] CountDown ['] UpDown DEFER! ENDOF ENDCASE AGAIN ; ' CountUp IS UpDown

Note that in this version of the program, we have moved CountUp and CountDown to the top. This is because they are ticked (with [']) in the definition of Counter, and of course, a word must already exist in order to obtain its execution token!

The real work in this program is in the CASE...ENDCASE structure. Notice that if the U key is detected (for "up") then the execution token of CountUp is written into the deferred word UpDown via DEFER!, causing the program to count upwards. Similarly, if D is pressed (for "down") then the execution token of CountDown is written into the deferred word UpDown via DEFER!.

Immediate Words

The definition of both IS and DEFER! as contained on block 73 of the utilities disk is intelligent. All deferred words, when created, are "standard" words (i.e. they are not immediate). If you subsequently associate an immediate word with your deferred word, the deferred word will be changed to immediate also. If you subsequently associate the same deferred word with a non-immediate word, the deferred word will be changed such that it is not immediate.

And there endeth the lesson on deferred words.

DEFER/IS Implementation

Below is the code found on block 73 of the utilities disk:

: iFlag@ ( xt -- f) \ return immediate status of the execution token. \ 0=non-immediate $8000=immediate. >link 2+ @ $8000 and ; : iFlag! ( xt f -- ) \ if f is true set the immediate status of the execution token \ to true, otherwise set it to false. swap >link 2+ dup >r @ swap if $8000 or else $7FFF and then r> ! ; : setImmed ( xt1 xt2 -- ) \ set xt2's immediate flag equal to xt1's immediate flag. swap iFlag@ iFlag! ; : dnop ( -- ) \ default run-time for newly created deferred words. true abort" Deferred action not set" ; : defer ( "name" -- ) \ create a deferred word from the name passed in on the command line. \ eg. defer this (creates a deferred word called this). create ['] dnop , does> @ execute ; : is ( xt "name" -- ) \ associate the deferred word "name" with the executable code addressed \ by xt. E.g: ' WORDS IS VLIST dup 0= abort" Target word not found" bl word find 0= abort" Deferred word not found" ( txt dxt ) 2dup >body ! setImmed ; : defer@ ( xt1 -- xt2) \ given the execution token of deferred word xt1, return the execution \ token of the run-time code associated with it. \ e.g: DEFER VLIST ' WORDS IS VLIST ' VLIST DEFER@ $. \ (displays the execution token of WORDS) >body @ ; : defer! ( xt1 xt2 -- ) \ given the execution token of deferred word xt2, sets it such that \ executing xt2 executes the code addressed by xt1. 2dup >body ! setImmed ;

Tests

Here's some tests that you can execute in TurboForth to test that deferred words are operating correctly. The following test assign deferred words to both immediate and non-immediate words, and checks that the deferred word changes to immediate/non-immediate as appropriate.

\ Tests: \ ------ \ standard deferred word (non-immediate) defer cls ' page is cls cls \ should clear the screen \ immediate deferred word (the deferred word inherits the \ immediate status of the target word) defer print" ' ." is print" : test print" This is a test" cr ; test \ create a deferred word defer thing \ assign it to a non-immediate word via DEFER! ' mem ' thing defer! \ thing should execute mem thing \ thing's immediate status should be 0: ' thing iFlag@ . \ Now re-assign thing to an immediate word: ' ." ' thing defer! \ create a definition using thing : thing-test thing this is a test of thing" ; thing-test \ things immediate status should now be 8000 hex \ since it now reflects an immediate word. ' thing iFlag@ $.

14 August 2013