|Column Tag:||FORTH FORUM
Forth Goes SANE
By Joerg Langowski
Forth Goes SANE
One of the little unexpected features of the Macintosh that was very important to me for doing some actual calculations is the built-in floating point package. There is a full set of floating point routines, ranging from the four basic operations up to trigonometric and other functions, built right into the Mac, and they can be called up through a standard toolbox calling procedure and turn out to be reasonably (if not really breathtakingly) fast. If you want to try out the floating point routines and have access to MacForth 1.1, the following should give you some useful information. MacForth level 2 supposedly makes use of the same routines, but it was not available at the time that this was written.
Lets first look at some general features. The floating point package, called FP68K by Apple, is based on a proposed IEEE floating point standard P754. It can work on 32, 64 and 80-bit floating point numbers and 16, 32, and 64-bit integers. Some of the operations that it supports are summarized in Table 1. (Because of space limitations, this table is by no means complete, but I tried to list the most important operations.) All calculations are internally done with 80-bit accuracy; this seems spectacular, but a little overdone. Speed could probably be improved a lot, had Apple allowed for working with lower precision.
Floating point operations are always called in the same manner: the addresses of the two arguments, source and destination, are pushed on the stack, followed by the opcode; then the toolbox trap _FP68K (for the basic operations) or _ELEMS68K (for the more complicated functions) is called. The result will be deposited in the destination address, which is overwritten. To understand the calling procedure better, let us see how toolbox traps are called from MacForth.
There are three types of toolbox traps in the Macintosh. Operating system traps expect a buffer pointer in register A0 and return an I/O result in D0; Pascal procedures expect their parameters on the stack, and Pascal functions expect a space for their result on the bottom of the stack, followed by all the parameters. MacForth 1.1 provides predefined words for all three trap types; they will be described in detail in the next issue of MacTech. The floating point package is called as a Pascal procedure, with its parameters on the stack. Since stack items in MacForth are 32 bits in length, while some of the toolbox procedures expect 16 bit parameters, there exist three different Forth words for Pascal-type calls, depending whether there are none, one or two 16-bit items on top of the stack: MT, W>MT and 2W>MT.
The floating point routines always expect one 16 bit parameter on top, all other parameters (up to three) are 32 bits long. The MacForth word to call these routines therefore would be W>MT. The trap addresses are $A9EB for FP68K and $A9EC for ELEMS68K. (These are, actually, the addresses of Package 4 and Package 5 of the Operating System Packages). We can now define our trap calls:
: A9EB W>MT FP68K ;
: A9EC W>MT ELEMS68K ;
Then we can call a floating point operation by pushing the parameters on the stack, followed by the opcode, and executing FP68K or ELEMS68K. As an example, if we had defined the 10-byte variables SOURCE and DESTINATION:
SOURCE CREATE 10 ALLOT
DESTINATION CREATE 10 ALLOT
and had put real numbers into both of them, we would add SOURCE into DESTINATION by executing:
SOURCE DESTINATION 0 FP68K
after which operation DESTINATION would contain the 80-bit result of the addition, while the contents of SOURCE would be unchanged. A function from the ELEMS68K package would be called in an equally simple way, e.g. the natural logarithm of DESTINATION is obtained by saying DESTINATION 0 FP68K .
The 16-bit opcode consists of two parts. The high order byte gives the format of the SOURCE operand (except for opcodes $9 and $10, see table 1), the low order byte specifies the operation. Listing 1 defines some Forth words that call the most important floating point operations through toolbox calls with the appropriate opcode on the stack.
There is one operation that deserves special attention, and that is the floating point - decimal conversion routine. This routine expects three parameters underneath the opcode: deepest in the stack is a pointer to a format record, followed by the source variable pointer, and then the destination pointer. For a conversion from a real number to a decimal number, the source variable is 10-byte floating point and the destination variable consists of a 2 byte integer which is 0 for positive and >256 for negative numbers, a 2 byte signed integer which contains the exponent, a 1 byte field which contains the length and a 20 byte field which contains the significant digits of the mantissa. The format record is, for our purposes, a 4 byte integer which gives the number of significant digits to be used in the conversion. Example, assume that Y points to the real number 2.345, DECSTRING to a 25-byte array and FORMAT to a 4-byte integer containing 10:
FORMAT Y DECSTRING B2D
will leave zero in the first two bytes of DECSTRING, +9 in the next two bytes, 10 in the next byte and the ASCII characters 2345000000xxxxxxxxxx thereafter (x = undefined). Vice versa, one can set up a decimal string in a 25 byte array according to these rules and call:
FORMAT DECSTRING Y D2B
which will leave the real number corresponding to DECSTRING in Y. The word DEC. (defined in listing 1) makes use of this conversion routine to output a real number.
Try and play with those floating point routines a little; they make a very useful addition to Forth 1.1, if you want to do any kind of numerical calculations. You may want to time the floating point package using the benchmarks at the end of listing 1. I found that an 80-bit precision add takes about 0.4 ms, a multiply about 1 ms.
In the next issue of MacTech we will take a closer look at toolbox calling from Forth and at the internal structure of Forth words, so that you can write in-line assembly code for time critical operations.