Return the address of a buffer containing a copy of the contents of block u, having read it from disk, if necessary. If a read occurred, the previous contents of the buffer is first written to disk, if it has been marked as updated.

BUFFER ( u — addr ) Block

Return the address of a buffer marked to contain block u, having written previous contents to disk, if necessary (does not perform any read operation).

UPDATE ( — ) Block

Mark the most recently referenced buffer as having been updated. The contents of a buffer that has been marked in this way will be written to disk when its buffer is needed for a different block.

Erase all block buffers without saving them. EMPTY-BUFFERS works by clearing the update bits in all buffers and performing a FLUSH to free the buffers.

3.4.3 Loading Forth Source Blocks

Most compiled languages require a three-step process to construct executable programs:

1.Compile the program to an object file on disk.

2.Link this program to other previously compiled and/or assembled routines.

3.Load the result into memory.

This often-lengthy procedure has a negative effect on a programmer’s effectiveness. Forth supports fully interactive programming by shortening this

System Functions 91

Forth Programmer’s Handbook

cycle to a single, fast operation: compiling from source to executable form in memory. This process is accomplished by the word LOAD.

3.4.3.1 The LOAD Operation

LOAD specifies the interpretation of source text from a disk block. LOAD expects on top of the stack the block number of the Forth block to be LOADed:

<number> LOAD

This block number is also stored in the variable BLK, used by Forth’s text interpreter. If BLK contains zero, the source is not a block, and usually is the terminal. When BLK is zero, the word SOURCE-ID returns a value indicating the input source (zero if it is the user input device or terminal, -1 if it is a character string passed by evaluate, and optionally a file-identifier if the input is a text file—see Section 3.5).

When LOAD is encountered, interpretation of text from the current input source is suspended and input is taken from the specified disk block. The text interpreter starts at the beginning and processes each word until it reaches the end of the block after 1024 characters. On some systems, if the word EXIT is encountered interpretively in the block, it will cause processing to terminate at once.

When all processing specified by the disk block is complete (assuming no errors were encountered while processing the block), execution resumes with input from the source that was in control when the LOAD was encountered.

If a block contains definitions, the result of a LOAD operation will be to process them via the text interpreter and compile them into the dictionary. The process of LOADing disk blocks is identical to processing the same information entered from the terminal or text file, but all information in a single disk block is processed as a single string (i.e., there will be no embedded carriage returns).

The block to be LOADed may itself contain a LOAD command, at which point the LOADing of the first block is suspended. When this occurs, the block number of the current block, the current text interpreter pointers are saved on the return stack, pending loading of the requested block. This nested LOADing process may continue indefinitely, subject to return stack size.

A group of blocks to be LOADed should be specified by LOAD commands con-

92 System Functions

Forth Programmer’s Handbook

tained in a single block, called a load block, as opposed to serial nesting (i.e., having each block load the next block in sequence). From a management viewpoint, loading groups of related blocks from a single load block aids readability and maintainability.

The command THRU can load a group of sequential blocks. For example, if blocks 260 through 270 need to be loaded, THRU could be used:

260 270 THRU

A LOAD operation may also be compiled in a definition, in which case the requested LOAD is done when the definition is executed. Following the LOAD, execution will resume at the word immediately after LOAD.

If an error is detected during the LOADing process, an error message is produced and all LOADing ceases. Both the return stack and the data stack are cleared, and Forth reverts to terminal input.

During loading, all text interpreter input is taken from the specified disk block. All output, however, proceeds to its normal destination. Thus, . (“dot”) or other output commands will send output to the terminal of the task executing the LOAD.

Execute LOAD in sequence for each of the blocks numbered u1 through u2. Any other stack effects are due to the words executed as a result of the LOADs.

System Functions 93

Forth Programmer’s Handbook

References EXIT, Section 2.5.5

Input source identification, Section 4.1.1

Text file identifiers, Section 3.5.1

3.4.3.2 Named Program Blocks

The defining word CONSTANT may be used to give names to important blocks, such as load blocks, which load other blocks to form a utility or application. For example, define:

120 CONSTANT OBSERVING

which will be used as:

OBSERVING LOAD

The above has the effect of loading block 120 and executing any other LOAD instructions specified in that block.

CONSTANT is particularly appropriate when you want to use the name in other ways, such as:

OBSERVING LIST

We recommend the use of a key block for each major section of an application. The key block should primarily load other associated blocks, specified numerically or through CONSTANTS; it may also contain other brief, application-wide definitions. Then you can see at a glance which of your application blocks are loaded, and in what order.

This technique is much safer than chaining blocks (i.e., serial nesting), which can cause a return-stack overflow. Generally, a single block names all the key blocks in that system, and is LOADed immediately after booting.

A convenient side effect of named blocks is that they can be successfully

!LOADed when in any number conversion base. But, for this reason, named key blocks should have a DECIMAL command in the first line to guard against incorrect loading of subsidiary blocks due to an unexpected current base.

94 System Functions