FORTH Q&A

By Jörg Langowski

Q: How can I write text and numbers to a window and have automatic wrap- around?

A: For one thing, Forth does not define the simple “.” or type words so as to provide an automatic CR when the end of the window is reached. This makes sense in some applications, such as printing out tables, when the window size is not known beforehand. On the other hand, it is rather annoying if one wants to test a simple definition to see half of the printout disappear off the right edge.

You might have noticed that the built-in Forth word, WORDS, does an automatic word wrap. So it almost looks like there is some hidden word in MacForth that tests for the end of the ‘screen’ and prints out a CR when it is reached. Lets look at the definition of WORDS, using the decompiler from an earlier issue of this journal. (I converted the BRANCHes to IFs etc. to make the code more readable). Please refer to figure 1.

: words
  context @ ?dup 
   if @ ?dup
     if dup @ + ( stack now contains address of latest definition )
        begin dup dup 1+ c@ swap c@ or while ( token <> 0 )
            2+ count 31 and 2dup 16 {2c7c} ( aha! hidden definition )
            dup {2c58} ( another one ) type 2 spaces
            + ( add name length, get next token )
        repeat
     drop then
   then;

Figure 1

The code is pretty sraightforward: The address of the CONTEXT vocabulary is put on the stack and the offset to the LATEST definition added to it. Then, after making sure it is not at the end of the list (token = 0), WORDS gets the name string of the definition and, after some manipulations, types it. The manipulations are done by two of those strange tokens that have no name associated with them, {2C7C} and {2C58}. They are defined as follows:

: {2c7c} col @ over wmod 1+ -
         dup {2c58} col @ if spaces else drop then ;

: {2c58} col @ +
         get.window +wbounds 6+ w@
         get.window +wline.height @ 7-
         w/ > if cr then ;

The first one, {2C7C} tabs to the next integer multiple of n, where n is the number on top of the stack, and wraps around if it would go beyond the limit of the window. The actual wraparound is done by {2C58}, which expects the number of characters to be output on top of the stack. It then compares the final cursor position to (right window edge)/(line height - 7), which is approximately the last column position in the window. If the string would print beyond this last position, a carriage return is output first. The ‘approximately’, by the way, is the reason why WORDS sometimes prints off the screen with non-standard text sizes. The remedy is to increase LINE.HEIGHT.

So you can very easily achieve automatic wrap when outputting text. For string output (with COUNT TYPE) you may redefine:

: wraptype dup 2c58 execute type ;

and any string you output using this word will automatically be confined to the window boundaries (more or less; in case of trouble change LINE.HEIGHT). For number output, you either have to know beforehand how many digits your number will have, or you write your number to string conversion routine and then use WRAPTYPE.

In the near future, we will solve the text output problem (and also the Cut/Paste problem) in a more elegant way by using the TextEdit functions. Stay tuned for an article on that.

Q: How can I get access to the toolbox routines that are not predefined in MacForth?

A: I hope your question has already been answered in one of my recent columns (there is this 3 months’ delay between writing the letter to us and getting the answer), but I’ll repeat that important point here.

MacForth provides defining words that support most of the toolbox routines. They are the following:

OS.TRAP - the address on top of stack (TOS) is an operating system trap, which is compiled into the definition of the following word. On execution, this word takes the 32-bit number on TOS, puts it into register A0 and executes the trap. The result is returned in the variable IO-RESULT.

MT - the address on TOS is a Pascal procedure type trap. All parameters to this procedure are 32-bit items. On execution, the trap is called with all the parameters passed through the stack. They have to be set up in the order given in the trap definition (in Inside Macintosh).

W>MT - the Pascal definition expects one 16-bit item on TOS. Therefore, the (32-bit) item on TOS is converted to a 16-bit item before the trap is called.

2W>MT - same as W>MT, the two topmost items on the stack are converted to 16 bits.

The third type of traps are Pascal function type traps. This means that you have to allocate space, either 16 or 32 bits, by pushing a zero before you push the arguments on the stack. This way, function type traps can be called through MT. For simple functions, MacForth provides four defining words that do this space allocation automatically:

FUNC>W - no argument, 16 bit result (converted to 32 bits)
FUNC>L - no argument, 32 bit result
W>FUNC>L - 16 bit argument, 32 bit result
L>FUNC>L - 32 bit argument, 32 bit result. 

For all other trap calls you have to write your custom stack set-up procedure, which is not too hard. The definition of NEW.CONTROL in the March issue gives an example for that. One important tool in writing such a toolbox trap definition is the routine PUSHW that changes TOS and the stack pointer in such a way that TOS is a 16-bit item:

: pushw s0 @ >r sp@ 2- s0 ! sp! r> s0 ! drop ;

Be cautious in using PUSHW; 16-bit pushes and calls that pull 16 bits have to match, otherwise the stack pointer may be 2 bytes out of frame.

Q: How do I use resources from MacForth?

A: The BLKS files contain no resources (as you might check using a resource editor - some of them are around now - or even a simple disk editor program). If you want to use the resource fork of a file, you have to generate the resources first with Rmaker (this program can also be found on several public domain disks). Rmaker, however, has the annoying habit of deleting the data fork of a file that is presented to him. Therefore, the correct procedure is to create a new file of the correct type and creator with Rmaker and put in the resources that you want. For example, the input to Rmaker might look like:

MyFile
BLKSM4TH

TYPE MENU
   ,1
\14

   ,2
Test
Item1
Item2
(-
Item4
Item5

This will create the file MyFile with the correct type (BLKS) and creator (M4TH) and put the Apple menu (ID=1) and a test menu (ID=2) into the resource fork. Of course, this file does not contain a data fork yet, so you have to add some blocks to it by executing

 “ MyFile” 1 assign
1 open
1 10 append.blocks

and you can put your Forth program text into those blocks. MacForth provides the word OPEN.RSRC for opening the resource fork of a file; you will have to read the resources through the appropriate toolbox routines, since there are no predefined words for getting resources from a file.

Since Forth programs are usually distributed in source form, however, I do not consider resources as critical as in other applications. However, if you develop stand-alone applications in Forth (I have not used Level 3 yet, but any comments are welcome), you might want to add the resources with Rmaker. I will deal with using resources in one of my next columns.