Forth is an unusual computer language that has probably been applied to more varied projects than any other. It is the obvious choice when the project is exceptionally demanding in terms of completion schedule, speed of execution, compactness of code, or any combination of the above.
It has also been called "...one of the best-kept secrets in the computing world." This is no exaggeration: large corporations have purchased professional Forth development systems from vendors such as Laboratory Microsystems, Inc., Forth, Inc. or MicroProcessor Engineering, Ltd. and sworn them to secrecy.
Some speculate (unkindly) that corporate giants prefer to hide their shame at using Forth; but I believe they are actually concealing a secret weapon from their rivals. Whenever Forth has competed directly with a more conventional language like C it has won hands down, producing smaller, faster, more reliable code in far less time. I have searched for examples with the opposite outcome, but have been unable to find a single instance.
We will use Ficl for these illustrations. Download the latest release and unzip it. The Win32 releases contain executable files ficl.exe and ficlwin.exe. I suggest you use ficlwin.exe because it supports copy and paste better, which will make it easier to enter the sample code.
Now start ficlwin.exe by double clicking the file icon in Windows Explorer It should respond by opening a window and writing something like:
ficl Version 3.01 Oct 28 2001 loading ficlwin.frFicl and Ficlwin are case-insensitive. Now type
bye <cr>The Ficl window immediately closes.
What just happened? Forth is an interactive programming language consisting entirely of subroutines, called "words". A word is executed (interactively) by naming it. We have just seen this happen: BYE
is a Forth subroutine meaning "exit to the operating system". So when we entered BYE
it was executed, and the system returned control to Windows.
Click on the Ficlwin icon again to re-start Forth. Now we will try something a little more complicated. Enter
2 17 + . <cr> 19 ok>
What happened? Forth is interpretive. An outer interpreter continually loops, waiting for input from the keyboard or mass storage device. The input is a sequence of text strings separated from each other by blank spaces -- ASCII 32decimal = 20hex -- the standard Forth delimiter.
When the outer interpreter encounters text it first looks for it in the dictionary (a linked list of previously defined subroutine names). If it finds the word, it executes the corresponding code.
If no dictionary entry exists, the interpreter tries to read the input as a number.
If the input text string satisfies the rules defining a number, it is converted to a number and stored in a special memory location called "the top of the stack" (TOS).
In the above example, Forth interpreted 2 and 17 as numbers, and pushed them both onto the stack.
+
is a pre-defined word as is .
, so they were looked up and executed.
+
added 2 to 17 and left 19 on the stack.
The word .
(called "emit") removed 19 from the stack and displayed it on the standard output device (in this case, CRT).
We might also have said
HEX 0A 14 * . <cr> C8 ok>(Do you understand this? Hint:
DECIMAL
means "switch to decimal arithmetic", whereas HEX
stands for "switch to hexadecimal arithmetic".) If the incoming text can neither be located in the dictionary nor interpreted as a number, Forth issues an error message. Try it: say X and see:
X X not foundOr say THING and see
THING THING not found
The compiler is one of Forth's most endearing features. Unlike all other high-level languages, the Forth compiler is part of the language. (LISP and its dialects also make components of the compilation mechanism available to the programmer.) That is, its components are Forth words available to the programmer, that can be used to solve his problems.
In this section we discuss how the compiler extends the dictionary.
Forth uses special words to create new dictionary entries, i.e., new words. The most important are :
("start a new definition") and ;
("terminate the definition").
Let's try this out: enter (where <cr>
means "press the Enter key")
: *+ * + ; <cr> ok>What happened? The word
:
was executed because it was already in the dictionary. The action of :
is
*+
and switch from interpret to compile mode.
*+
will be to execute sequentially the previously-defined words *
and +
.
;
is special: when it was defined a bit was turned on in its dictionary entry to mark it as IMMEDIATE
. Thus, rather than writing down its address, the compiler executes ;
immediately. The action of ;
is first, to install the code that returns control to the next outer level of the interpreter; and second, to switch back from compile mode to interpret mode.
ok>
to acknowledge that something happened.
*+
:
DECIMAL 5 6 7 *+ . <cr> 47 ok>
This example illustrated two principles of Forth: adding a new word to the dictionary, and trying it out as soon as it was defined.
We now discuss the stack and the "reverse Polish" or "postfix" arithmetic based on it. (Anyone who has used a Hewlett-Packard calculator should be familiar with the concept.)
Virtually all modern CPU's are designed around stacks. Forth efficiently uses its CPU by reflecting this underlying stack architecture in its syntax.
But what is a stack? As the name implies, a stack is the machine anlog of a pile of cards with numbers written on them. Numbers are always added to the top of the pile, and removed from the top of the pile. The Forth input line
2 5 73 -16 <cr> ok>leaves the stack in the state
cell # contents 0 -16 (TOS) 1 73 (NOS) 2 5 3 2where TOS stands for "top-of-stack", NOS for "next-on-stack", etc.
.s
to display the stack contents in a non-destructive way.
We usually employ zero-based relative numbering in Forth data structures (such as stacks, arrays, tables, etc.) so TOS is given relative #0, NOS #1, etc.
Suppose we followed the above input line with the line
+ - * . <cr> xxx ok>what would
xxx
be? The operations would produce the successive stacks
initial + - * . -16 57 -52 -104 (empty 73 5 2 stack) 5 2 2The operation
.
(EMIT) displays -104 to the screen, leaving the stack empty. That is, xxx is -104.
Forth systems incorporate (at least) two stacks: the parameter stack and the return stack.
A stack-based system must provide ways to put numbers on the stack, to remove them, and to rearrange their order. Forth includes standard words for this purpose.
Putting numbers on the stack is easy: simply type the number (or incorporate it in the definition of a Forth word).
The word DROP
removes the number from TOS and moves up all the other numbers. (Since the stack usually grows downward in memory, DROP
merely increments the pointer to TOS by 1 cell.)
SWAP
exchanges the top 2 numbers.
DUP
duplicates the TOS into NOS.
ROT
rotates the top 3 numbers.
cell | initial | DROP SWAP ROT DUP 0 | -16 | 73 73 5 -16 1 | 73 | 5 -16 -16 -16 2 | 5 | 2 5 73 73 3 | 2 | 2 2 5 4 | | 2
Forth includes the words OVER, TUCK, PICK and ROLL that act as shown below (note PICK
and ROLL
must be preceded by an integer that says where on the stack an element gets PICK'ed or ROLL'ed):
cell | initial | OVER TUCK 4 PICK 4 ROLL 0 | -16 | 73 -16 2 2 1 | 73 | -16 73 -16 -16 2 | 5 | 73 -16 73 73 3 | 2 | 5 5 5 5 4 | | 2 2 2Clearly,
1 PICK
is the same as DUP
, 2 PICK
is a synonym for OVER
, and 2 ROLL
means SWAP
.
We have remarked above that compilation establishes links from the calling word to the previously-defined word being invoked. The linkage mechanism --during execution-- uses the return stack (rstack): the address of the next word to be invoked is placed on the rstack, so that when the current word is done executing, the system knows to jump to the next word. (This is so in most, but not all Forth implementations. But all have a return stack, whether or not they use them for linking subroutines.)
In addition to serving as a reservoir of return addresses (since words can be nested, the return addresses need a stack to be put on) the rstack is where the limits of a DO...LOOP construct are placed.
The user can also store/retrieve to/from the rstack. This is an example of using a component for a purpose other than the one it was designed for. Such use is discouraged for novices since it adds the spice of danger to programming. See "Note of caution" below.
To store to the rstack we say >R
, and to retrieve we say R>
. The word R@
copies the top of the rstack to the TOS.
Why use the rstack when we have a perfectly good parameter stack to play with? Sometimes it becomes hard to read code that performs complex gymnastics on the stack. The rstack can reduce the complexity.
Alternatively, VARIABLE
s --named locations-- provide a place to store numbers --such as intermediate results in a calculation-- off the stack, again reducing the gymnastics. Try this:
\ YOU DO THIS \ EXPLANATION VARIABLE X <cr> ok> \ create a named storage location X; \ X executes by leaving its address 3 X ! <cr> ok> \ ! ("store") expects a number and \ an address, and stores the number to \ that address X @ . <cr> 3 ok> \ @ ("fetch") expects an address, and \ places its contents in TOS.
However, Forth encourages using as few named variables as possible. The reason: since VARIABLE
s are typically global -- any subroutine can access them -- they can cause unwanted interactions among parts of a large program.
Ficl note: Ficl supports named local variables efficiently. You can use them to simplify the stack logic of many words.
Although Forth can make variables local to the subroutines that use them (see "headerless words" in FTR), the rstack can often replace local variables:
A note of caution: since the rstack is critical to execution we mess with it at our peril. If we use the rstack for temporary storage we must restore it to its initial state. A word that places a number on the rstack must remove it --using R>
or RDROP
(if it has been defined) -- before exiting that word. Since DO...LOOP
and other control constructs also use the rstack for their internal bookkeeping, for each >R
following DO
there must be a corresponding R>
or RDROP
preceding LOOP
. Neglecting these precautions will probably crash the system.
As we just saw, ordinary numbers are fetched from memory to the stack by @
("fetch"), and stored by !
(store).
@
expects an address on the stack and replaces that address by its contents using, e.g., the phrase X @
!
expects a number (NOS) and an address (TOS) to store it in, and places the number in the memory location referred to by the address, consuming both arguments in the process, as in the phrase 3 X !
Double length numbers can similarly be fetched and stored, by D@
and D!
, if the system has these words.
Positive numbers smaller than 255 can be placed in single bytes of memory using C@
and C!
. This is convenient for operations with strings of ASCII text, for example screen and keyboard I/O.
Forth lets you compare two numbers on the stack, using relational operators >
, lt;
, =
. Thus, e.g., the phrase
2 3 > <cr> ok>leaves 0 (
false
) on the stack, because 2 (NOS) is not greater than 3 (TOS). Conversely, the phrase
2 3 < <cr> ok>leaves -1 (
true
) because 2 is less than 3.
Notes:
true
is +1 rather than -1.
(Many Forths offer unary relational operators 0=
, 0<>
, 0>
and 0<
. These, as might be guessed, determine whether the TOS contains an integer that is 0, nonzero, positive or negative.)
The relational words are used for branching and control. For example:
: TEST CR 0<> IF ." Not zero!" ENDIF ; 0 TEST <cr> ok> ( no action) -14 TEST <cr> Not zero! ok>
The word CR
issues a carriage return (newline). Then TOS is compared with zero, and the logical NOT operator (this flips true
and false
) applied to the resulting flag. Finally, if TOS is non-zero, IF
swallows the flag and executes all the words between itself and the terminating THEN
(Note: Ficl has endif
as a less confusing synonym). If TOS is zero, execution jumps to the word following THEN
.
The word ELSE
is used in the IF...ELSE...THEN
statement: a nonzero value in TOS causes any words between IF
and ELSE
to be executed, and words between ELSE
and THEN
to be skipped. A zero value produces the opposite behavior. Thus, e.g.
: TRUTH CR 0= IF ." false" ELSE ." true" THEN ; 1 TRUTH <cr> true ok> 0 TRUTH <cr> false ok>
Since THEN is used to terminate an IF statement rather than in its more conventional sense, some Forth writers prefer the name ENDIF.
Ficl Note: Ficl defines endif
as a synonym for THEN
.
Forth is sometimes accused of being a "write-only" language, i.e. some complain that Forth is cryptic. This is really a complaint against poor documentation and untelegraphic word names. Unreadability is equally a flaw of poorly written FORTRAN, PASCAL, C, etc.
Forth offers programmers who take the trouble tools for producing exceptionally clear code.
The word (
-- a left parenthesis followed by a space -- says "disregard all following text until the next right parenthesis in the input stream". Thus we can intersperse explanatory remarks within colon definitions.
A particular form of parenthesized remark describes the effect of a word on the stack. In the example of a recursive loop (GCD below), stack comments are really all the documentation necessary.
Glossaries generally explain the action of a word with a stack-effect comment. For example,
( adr -- n)describes the word
@
("fetch"): it says @
expects to find an address (adr) on the stack, and to leave its contents (n) upon completion. The corresponding comment for !
would be
( n adr -- ) .
\
(back-slash followed by space) is a method for including longer comments. It simply means "drop everything in the input stream until the next carriage return". Instructions to the user, clarifications or usage examples are most naturally expressed in a block of text with each line set off by \
.
2 TIMES LEFT EYE WINKwhich is clear (although it sounds like a stage direction for Brunhilde to vamp Siegfried). It would even be possible without much difficulty to define the words in the program so that the sequence could be made English-like:
WINK LEFT EYE 2 TIMES
The American National Standard requires that a conforming Forth system contain a certain minimum set of pre-defined words. These consist of arithmetic operators + - * / MOD /MOD */
for (usually) 32-bit signed-integer arithmetic, and equivalents for unsigned, double-length and mixed-mode (32- mixed with 64-bit) arithmetic. The list will be found in the glossary accompanying your system, as well as in SF and FTR.
Try this example of a non-trivial program that uses arithmetic and branching to compute the greatest common divisor of two integers using Euclid's algorithm:
: TUCK ( a b -- b a b) SWAP OVER ; : GCD ( a b -- gcd) ?DUP IF TUCK MOD GCD THEN ;The word
?DUP
duplicates TOS if it is not zero, and leaves it alone otherwise. If the TOS is 0, therefore, GCD
consumes it and does nothing else. However, if TOS is unequal to 0, then GCD TUCK
s TOS under NOS (to save it); then divides NOS by TOS, keeping the remainder (MOD
). There are now two numbers left on the stack, so we again take the GCD
of them. That is, GCD
calls itself. However, if you try the above code it will fail. A dictionary entry cannot be looked up and found until the terminating ;
has completed it. So in fact we must use the word RECURSE
to achieve self-reference, as in
: TUCK ( a b -- b a b) SWAP OVER ; : GCD ( a b -- gcd) ?DUP IF TUCK MOD RECURSE THEN ;Now try
784 48 GCD . 16 ok>
BEGIN xxx ( -- flag) UNTILexecutes the words represented by xxx, leaving TOS (flag) set to TRUE -- at which point UNTIL terminates the loop-- or to FALSE --at which point UNTIL jumps back to BEGIN. Try:
: COUNTDOWN ( n --) BEGIN CR DUP . 1 - DUP 0 = UNTIL DROP ; 5 COUNTDOWN 5 4 3 2 1 ok>A variant of
BEGIN...UNTIL
is
BEGIN xxx ( -- flag) WHILE yyy REPEAT
Here xxx is executed, WHILE tests the flag and if it is FALSE
leaves the loop; if the flag is TRUE
, yyy is executed; REPEAT
then branches back to BEGIN
.
These forms can be used to set up loops that repeat until some external event (pressing a key at the keyboard, e.g.) sets the flag to exit the loop. They can also used to make endless loops (like the outer interpreter of Forth) by forcing the flag to be FALSE in a definition like
: ENDLESS BEGIN xxx FALSE UNTIL ;
DO...LOOP
(or +LOOP
). These are permitted only within definitions
: BY-ONES ( n --) 0 TUCK DO CR DUP . 1 + LOOP DROP ;
The words CR DUP . 1 +
will be executed n times as the lower limit, 0, increases in unit steps to n-1.
To step by 2's, we use the phrase 2 +LOOP
to replace LOOP
, as with
: BY-TWOS ( n --) 0 TUCK DO CR DUP . 2 + 2 +LOOP DROP ;
N. Wirth invented the Pascal language in reaction to program flow charts resembling a plate of spaghetti. Such flow diagrams were often seen in early languages like FORTRAN and assembler. Wirth intended to eliminate line labels and direct jumps (GOTOs), thereby forcing control flow to be clear and direct.
The ideal was subroutines or functions that performed a single task, with unique entries and exits. Unfortunately, programmers insisted on GOTOs, so many Pascals and other modern languages now have them. Worse, the ideal of short subroutines that do one thing only is unreachable in such languages because the method for calling them and passing arguments imposes a large overhead. Thus execution speed requires minimizing calls, which in turn means longer, more complex subroutines that perform several related tasks. Today structured programming seems to mean little more than writing code with nested IFs indented by a pretty-printer.
Paradoxically, Forth is the only truly structured language in common use, although it was not designed with that as its goal. In Forth word definitions are subroutine calls. The language contains no GOTO's so it is impossible to write "spaghetti code". Forth also encourages structure through short definitions. The additional running time incurred in breaking a long procedure into many small ones (this is called "factoring") is typically rather small in Forth. Each Forth subroutine (word) has one entry and one exit point, and can be written to perform a single job.
CREATE...DOES>
, the "pearl of Forth". CREATE is a component of the compiler, whose function is to make a new dictionary entry with a given name (the next name in the input stream) and nothing else. DOES>
assigns a specific run-time action to a newly CREATE
d word.
CREATE
finds its most important use in extending the powerful class of Forth words called "defining" words. The colon compiler :
is such a word, as are VARIABLE
and CONSTANT
.
The definition of VARIABLE in high-level Forth is simple
: VARIABLE CREATE 1 CELLS ALLOT ;We have already seen how
VARIABLE
is used in a program. (An alternative definition found in some Forths (not Ficl) is
: VARIABLE CREATE 0 , ;--these variables are initialized to 0.)
Forth lets us define words initialized to contain specific values: for example, we might want to define the number 17 to be a word. CREATE
and ,
("comma") can do this:
17 CREATE SEVENTEEN , <cr> ok>Now test it via
SEVENTEEN @ . <cr> 17 ok>
,
("comma") puts TOS into the next cell of the dictionary and increments the dictionary pointer by that number of bytes.
C,
("see-comma") exists also -- it puts a character into the next character-length slot of the dictionary and increments the pointer by 1 such slot. (If the character representation is ASCII the slots are 1 byte--Unicode requires 2 bytes.)
In the preceding example, we were able to initialize the variable SEVENTEEN
to 17 when we CREATE
d it, but we still have to fetch it to the stack via SEVENTEEN @ whenever we want it. This is not quite what we had in mind: we would like to find 17 in TOS when SEVENTEEN is named. The word DOES>
gives us the tool to do this.
The function of DOES>
is to specify a run-time action for the "child" words of a defining word. Consider the defining word CONSTANT
, defined in high-level (of course CONSTANT
is usually defined in machine code for speed) Forth by
: CONSTANT CREATE , DOES> @ ;and used as
53 CONSTANT PRIME <cr> ok>Now test it:
PRIME . <cr> 53 ok>What is happening here?
CREATE
(hidden in CONSTANT
) makes an entry named PRIME
(the first word in the input stream following CONSTANT
). Then ,
places the TOS (the number 53) in the next cell of the dictionary.
DOES>
(inside CONSTANT
) appends the actions of all words between it and ;
(the end of the definition) -- in this case, @
-- to the child word(s) defined by CONSTANT.
Here is an example of the power of defining words and of the distinction between compile-time and run-time behaviors.
Physical problems generally involve quantities that have dimensions, usually expressed as mass (M), length (L) and time (T) or products of powers of these. Sometimes there is more than one system of units in common use to describe the same phenomena.
For example, U.S. or English police reporting accidents might use inches, feet and yards; while Continental police would use centimeters and meters. Rather than write different versions of an accident analysis program it is simpler to write one program and make unit conversions part of the grammar. This is easy in Forth.
The simplest method is to keep all internal lengths in millimeters, say, and convert as follows:
: INCHES 254 10 */ ; : FEET [ 254 12 * ] LITERAL 10 */ ; : YARDS [ 254 36 * ] LITERAL 10 */ ; : CENTIMETERS 10 * ; : METERS 1000 * ;Note: This example is based on integer arithmetic. The word
*/
means "multiply the third number on the stack by NOS, keeping double precision, and divide by TOS". That is, the stack comment for */
is
( a b c -- a*b/c)
.
The usage would be
10 FEET . <cr> 3048 ok>
The word [
switches from compile mode to interpret mode while compiling. (If the system is interpreting it changes nothing.) The word ]
switches from interpret to compile mode.
Barring some error-checking, the "definition" of the colon compiler :
is just
: : CREATE ] DOES> doLIST ;and that of
;
is just
: ; next [ ; IMMEDIATEAnother use for these switches is to perform arithmetic at compile-time rather than at run-time, both for program clarity and for easy modification, as we did in the first try at dimensioned data (that is, phrases such as
[ 254 12 * ] LITERALand
[ 254 36 * ] LITERALwhich allowed us to incorporate in a clear manner the number of tenths of millimeters in a foot or a yard.
The preceding method of dealing with units required unnecessarily many definitions and generated unnecessary code. A more compact approach uses a defining word, UNITS
:
: D, ( hi lo --) SWAP , , ; : D@ ( adr -- hi lo) DUP @ SWAP 2 + @ ; : UNITS CREATE D, DOES> D@ */ ;Then we could make the table
254 10 UNITS INCHES 254 12 * 10 UNITS FEET 254 36 * 10 UNITS YARDS 10 1 UNITS CENTIMETERS 1000 1 UNITS METERS \ Usage: 10 FEET . <cr> 3048 ok> 3 METERS . <cr> 3000 ok> \ ....................... \ etc.This is an improvement, but Forth permits a simple extension that allows conversion back to the input units, for use in output:
VARIABLE <AS> 0 <AS> ! : AS TRUE <AS> ! ; : ~AS FALSE <AS> ! ; : UNITS CREATE D, DOES> D@ <AS> @ IF SWAP THEN */ ~AS ; \ UNIT DEFINITIONS REMAIN THE SAME. \ Usage: 10 FEET . <cr> 3048 ok> 3048 AS FEET . <cr> 10 ok>
Suppose we have a series of push-buttons numbered 0-3, and a word WHAT
to read them. That is, WHAT waits for input from a keypad: when button #3 is pushed, for example, WHAT leaves 3 on the stack.
We would like to define a word BUTTON to perform the action of pushing the n'th button, so we could just say:
WHAT BUTTONBUTTON could look something like
: BUTTON DUP 0 = IF RING DROP EXIT THEN DUP 1 = IF OPEN DROP EXIT THEN DUP 2 = IF LAUGH DROP EXIT THEN DUP 3 = IF CRY DROP EXIT THEN ABORT" WRONG BUTTON!" ;That is, we would have to go through two decisions on the average. Forth makes possible a much neater algorithm, involving a "jump table". [Note: Forth never standardized the common CASE statement, but as you will see it is easy to implement one]. The mechanism by which Forth executes a subroutine is to feed its "execution token" (often an address, but not necessarily) to the word EXECUTE. If we have a table of execution tokens we need only look up the one corresponding to an index (offset into the table) fetch it to the stack and say EXECUTE.
One way to code this is
CREATE BUTTONS ' RING , ' OPEN , ' LAUGH , ' CRY , : BUTTON ( nth --) 0 MAX 3 MIN CELLS BUTTONS + @ EXECUTE ;Note how the phrase
0 MAX 3 MIN
protects against an out-of-range index. Although the Forth philosophy is not to slow the code with unnecessary error checking (because words are checked as they are defined), when programming a user interface some form of error handling is vital. It is usually easier to prevent errors as we just did, than to provide for recovery after they are made.
How does the action-table method work?
BUTTONS
now contains xt's of the various actions of BUTTON.
BUTTONS
of the desired xt.
BUTTONS
to get the absolute address where the xt is stored.
@
fetches the xt for EXECUTE
to execute.
EXECUTE
then executes the word corresponding to the button pushed. Simple!
: ;CASE ; \ do-nothing word : CASE: CREATE HERE -1 >R 0 , \ place for length BEGIN BL WORD FIND \ get next subroutine 0= IF CR COUNT TYPE ." not found" ABORT THEN R> 1+ >R DUP , ['] ;CASE = UNTIL R> 1- SWAP ! \ store length DOES> DUP @ ROT ( -- base_adr len n) MIN 0 MAX \ truncate index CELLS + CELL+ @ EXECUTE ;Note the two forms of error checking. At compile-time,
CASE:
aborts compilation of the new word if we ask it to point to an undefined subroutine:
case: test1 DUP SWAP X ;case X not foundand we count how many subroutines are in the table (including the do-nothing one,
;case
) so that we can force the index to lie in the range [0,n].
CASE: TEST * / + - ;CASE ok 15 3 0 TEST . 45 ok 15 3 1 TEST . 5 ok 15 3 2 TEST . 18 ok 15 3 3 TEST . 12 ok 15 3 4 TEST . . 3 15 okJust for a change of pace, here is another way to do it:
: jtab: ( Nmax --) \ starts compilation CREATE \ make a new dictionary entry 1- , \ store Nmax-1 in its body ; \ for bounds clipping : get_xt ( n base_adr -- xt_addr) DUP @ ( -- n base_adr Nmax-1) ROT ( -- base_adr Nmax-1 n) MIN 0 MAX \ bounds-clip for safety 1+ CELLS+ ( -- xt_addr = base + 1_cell + offset) ; : | ' , ; \ get an xt and store it in next cell : ;jtab DOES> ( n base_adr --) \ ends compilation get_xt @ EXECUTE \ get token and execute it ; \ appends table lookup and execute code \ Example: : Snickers ." It's a Snickers Bar!" ; \ stub for test \ more stubs 5 jtab: CandyMachine | Snickers | Payday | M&Ms | Hershey | AlmondJoy ;jtab 3 CandyMachine It's a Hershey Bar! ok> 1 CandyMachine It's a Payday! ok> 7 CandyMachine It's an Almond Joy! ok> 0 CandyMachine It's a Snickers Bar! ok> -1 CandyMachine It's a Snickers Bar! ok>
Although Forth at one time eschewed floating point arithmetic (because in the era before math co-processors integer arithmetic was 3x faster), in recent years a standard set of word names has been agreed upon. This permits the exchange of programs that will operate correctly on any computer, as well as the development of a Scientific Subroutine Library in Forth (FSL).
Although the ANS Standard does not require a separate stack for floating point numbers, most programmers who use Forth for numerical analysis employ a separate floating point stack; and most of the routines in the FSL assume such. We shall do so here as well.
The floating point operators have the following names and perform the actions indicated in the accompanying stack comments:
@ ( adr --) ( f: -- x) F! ( adr --) ( f: x --) F+ ( f: x y -- x+y) F- ( f: x y -- x-y) F* ( f: x y -- x*y) F/ ( f: x y -- x/y) FEXP ( f: x -- e^x) FLN ( f: x -- ln[x]) FSQRT ( f: x -- x^0.5)
Additional operators, functions, trigonometric functions, etc. can be found in the FLOATING and FLOATING EXT wordsets. (See dpANS12)
To aid in using floating point arithmetic I have created a simple FORTRAN-like interface for incorporating formulas into Forth words.
The file ftest.f (included below) illustrates how ftran111.f should be used.
\ Test for ANS FORmula TRANslator marker-test fvariable a fvariable b fvariable c fvariable d fvariable x fvariable w : test0 f" b+c" cr fe. f" b-c" cr fe. f" (b-c)/(b+c)" cr fe. ; 3.e0 b f! 4.e0 c f! see test0 test0 : test1 f" a=b*c-3.17e-5/tanh(w)+abs(x)" a f@ cr fe. ; 1.e-3 w f! -2.5e0 x f! cr cr see test1 test1 cr cr : test2 f" c^3.75" cr fe. f" b^4" cr fe. ; see test2 test2 \ Baden's test case : quadroot c f! b f! a f! f" d = sqrt(b^2-4*a*c) " f" (-b+d)/(2*a) " f" (-b-d)/(2*a) " ; cr cr see quadroot : goldenratio f" max(quad root(1,-1,-1)) " ; cr cr see goldenratio cr cr goldenratio f.Output should look like:
: test0 c f@ b f@ f+ cr fe. c f@ fnegate b f@ f+ cr fe. c f@ fnegate b f@ f+ c f@ b f@ f+ f/ cr fe. ; 7.00000000000000E0 -1.00000000000000E0 -142.857142857143E-3 : test1 x f@ fabs 3.17000000000000E-5 w f@ ftanh f/ fnegate b f@ c f@ f* f+ f+ a f! a f@ cr fe. ; 14.4682999894333E0 ok> : test2 c f@ noop 3.75000000000000E0 f** cr fe. b f@ f^4 cr fe. ; 181.019335983756E0 81.0000000000000E0 ok> : QUADROOT C F! B F! A F! B F@ F^2 flit 4.00000 A F@ C F@ F* F* F- FSQRT D F! B F@ FNEGATE D F@ F+ flit 2.00000 A F@ F* F/ B F@ FNEGATE D F@ F- flit 2.00000 A F@ F* F/ ; : GOLDENRATIO flit 1.00000 flit -1.00000 flit -1.00000 QUADROOT FMAX ; 1.61803 ok>with more or fewer places.